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
|
|
|
|
2011-02-05 07:00:12 -05:00
|
|
|
Copyright 2009-2011 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/>.
|
2011-01-15 17:17:16 -05:00
|
|
|
*/
|
2010-03-24 13:48:38 -04:00
|
|
|
package org.yaaic.activity;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
2010-08-29 10:42:50 -04:00
|
|
|
import java.util.ArrayList;
|
2010-03-21 11:37:56 -04:00
|
|
|
import java.util.Collection;
|
2010-08-29 10:42:50 -04:00
|
|
|
import java.util.List;
|
2010-03-21 11:37:56 -04:00
|
|
|
|
2010-03-05 09:56:57 -05:00
|
|
|
import org.yaaic.R;
|
|
|
|
import org.yaaic.Yaaic;
|
|
|
|
import org.yaaic.adapter.DeckAdapter;
|
2010-03-13 18:03:38 -05:00
|
|
|
import org.yaaic.adapter.MessageListAdapter;
|
2010-03-09 13:46:02 -05:00
|
|
|
import org.yaaic.command.CommandParser;
|
2010-03-05 09:56:57 -05:00
|
|
|
import org.yaaic.irc.IRCBinder;
|
2010-08-27 11:45:47 -04:00
|
|
|
import org.yaaic.irc.IRCConnection;
|
2010-03-05 09:56:57 -05:00
|
|
|
import org.yaaic.irc.IRCService;
|
2010-03-17 16:52:51 -04:00
|
|
|
import org.yaaic.layout.NonScalingBackgroundDrawable;
|
2010-05-12 05:44:34 -04:00
|
|
|
import org.yaaic.listener.ConversationClickListener;
|
2010-03-14 17:13:23 -04:00
|
|
|
import org.yaaic.listener.ConversationListener;
|
2010-05-12 05:44:34 -04:00
|
|
|
import org.yaaic.listener.ConversationSelectedListener;
|
2010-03-10 17:28:49 -05:00
|
|
|
import org.yaaic.listener.ServerListener;
|
2010-08-29 10:42:50 -04:00
|
|
|
import org.yaaic.listener.SpeechClickListener;
|
2010-03-05 09:56:57 -05:00
|
|
|
import org.yaaic.model.Broadcast;
|
2011-05-29 20:49:53 -04:00
|
|
|
import org.yaaic.model.Channel;
|
2010-03-10 14:56:14 -05:00
|
|
|
import org.yaaic.model.Conversation;
|
2010-04-06 16:45:32 -04:00
|
|
|
import org.yaaic.model.Extra;
|
2010-03-06 11:52:22 -05:00
|
|
|
import org.yaaic.model.Message;
|
2011-02-05 10:04:22 -05:00
|
|
|
import org.yaaic.model.Query;
|
2010-04-12 14:41:31 -04:00
|
|
|
import org.yaaic.model.Scrollback;
|
2010-03-05 09:56:57 -05:00
|
|
|
import org.yaaic.model.Server;
|
2010-04-13 15:55:47 -04:00
|
|
|
import org.yaaic.model.ServerInfo;
|
2010-09-05 16:04:55 -04:00
|
|
|
import org.yaaic.model.Settings;
|
2010-03-21 10:26:11 -04:00
|
|
|
import org.yaaic.model.Status;
|
2011-02-05 10:04:22 -05:00
|
|
|
import org.yaaic.model.User;
|
2010-03-14 17:13:23 -04:00
|
|
|
import org.yaaic.receiver.ConversationReceiver;
|
2010-03-10 17:28:49 -05:00
|
|
|
import org.yaaic.receiver.ServerReceiver;
|
2010-05-12 04:30:07 -04:00
|
|
|
import org.yaaic.view.ConversationSwitcher;
|
2011-05-29 20:47:18 -04:00
|
|
|
import org.yaaic.view.MessageListView;
|
2009-12-17 15:27:57 -05:00
|
|
|
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.app.Activity;
|
|
|
|
import android.app.AlertDialog;
|
|
|
|
import android.content.ComponentName;
|
2010-10-27 15:30:17 -04:00
|
|
|
import android.content.Context;
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.content.DialogInterface;
|
|
|
|
import android.content.Intent;
|
|
|
|
import android.content.IntentFilter;
|
|
|
|
import android.content.ServiceConnection;
|
2010-08-29 10:42:50 -04:00
|
|
|
import android.content.pm.PackageManager;
|
|
|
|
import android.content.pm.ResolveInfo;
|
2011-05-29 20:50:00 -04:00
|
|
|
import android.content.res.Configuration;
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.os.Bundle;
|
2011-02-05 10:04:22 -05:00
|
|
|
import android.os.Handler;
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.os.IBinder;
|
2010-08-29 10:42:50 -04:00
|
|
|
import android.speech.RecognizerIntent;
|
2011-05-29 20:50:00 -04:00
|
|
|
import android.text.InputType;
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.view.KeyEvent;
|
|
|
|
import android.view.Menu;
|
|
|
|
import android.view.MenuInflater;
|
|
|
|
import android.view.MenuItem;
|
|
|
|
import android.view.View;
|
2011-02-22 11:31:51 -05:00
|
|
|
import android.view.View.OnKeyListener;
|
2011-03-14 17:15:13 -04:00
|
|
|
import android.view.Window;
|
2011-01-15 17:17:16 -05:00
|
|
|
import android.view.inputmethod.InputMethodManager;
|
2010-08-29 10:42:50 -04:00
|
|
|
import android.widget.Button;
|
2010-08-27 11:45:47 -04:00
|
|
|
import android.widget.EditText;
|
|
|
|
import android.widget.Gallery;
|
|
|
|
import android.widget.ImageView;
|
|
|
|
import android.widget.TextView;
|
|
|
|
import android.widget.Toast;
|
|
|
|
import android.widget.ViewSwitcher;
|
|
|
|
|
2009-12-17 15:27:57 -05:00
|
|
|
/**
|
2010-03-08 15:38:29 -05:00
|
|
|
* The server view with a scrollable list of all channels
|
2009-12-17 15:27:57 -05:00
|
|
|
*
|
|
|
|
* @author Sebastian Kaspari <sebastian@yaaic.org>
|
|
|
|
*/
|
2011-05-29 20:49:56 -04:00
|
|
|
public class ConversationActivity extends Activity implements ServiceConnection, ServerListener, ConversationListener
|
2009-12-17 15:27:57 -05:00
|
|
|
{
|
2010-11-18 12:52:19 -05:00
|
|
|
public static final int REQUEST_CODE_SPEECH = 99;
|
|
|
|
|
|
|
|
private static final int REQUEST_CODE_JOIN = 1;
|
|
|
|
private static final int REQUEST_CODE_USERS = 2;
|
|
|
|
private static final int REQUEST_CODE_USER = 3;
|
|
|
|
private static final int REQUEST_CODE_NICK_COMPLETION= 4;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
private int serverId;
|
|
|
|
private Server server;
|
|
|
|
private IRCBinder binder;
|
|
|
|
private ConversationReceiver channelReceiver;
|
|
|
|
private ServerReceiver serverReceiver;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
private ViewSwitcher switcher;
|
|
|
|
private Gallery deck;
|
|
|
|
private DeckAdapter deckAdapter;
|
|
|
|
private Scrollback scrollback;
|
|
|
|
private ConversationSwitcher dots;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// XXX: This is ugly. This is a buffer for a channel that should be joined after showing the
|
|
|
|
// JoinActivity. As onActivityResult() is called before onResume() a "channel joined"
|
|
|
|
// broadcast may get lost as the broadcast receivers are registered in onResume() but the
|
|
|
|
// join command would be called in onActivityResult(). joinChannelBuffer will save the
|
|
|
|
// channel name in onActivityResult() and run the join command in onResume().
|
|
|
|
private String joinChannelBuffer;
|
|
|
|
|
|
|
|
// flag passed to setInputType later
|
|
|
|
// shall be TYPE_TEXT_FLAG_NO_SUGGESTIONS but it's not supported in all API levels (only in 5+)
|
|
|
|
// We'll set it to 0 if it's not supported
|
|
|
|
private int setInputTypeFlag;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-05-29 20:49:49 -04:00
|
|
|
private int historySize;
|
|
|
|
|
2011-05-29 20:49:56 -04:00
|
|
|
OnKeyListener inputKeyListener = new OnKeyListener() {
|
|
|
|
/**
|
|
|
|
* On key pressed (input line)
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean onKey(View view, int keyCode, KeyEvent event)
|
|
|
|
{
|
|
|
|
EditText input = (EditText) view;
|
|
|
|
|
|
|
|
if (event.getAction() != KeyEvent.ACTION_DOWN) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
|
|
|
|
String message = scrollback.goBack();
|
|
|
|
if (message != null) {
|
|
|
|
input.setText(message);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
|
|
|
|
String message = scrollback.goForward();
|
|
|
|
if (message != null) {
|
|
|
|
input.setText(message);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keyCode == KeyEvent.KEYCODE_ENTER) {
|
|
|
|
sendMessage(input.getText().toString());
|
|
|
|
input.setText("");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Nick completion
|
|
|
|
if (keyCode == KeyEvent.KEYCODE_SEARCH) {
|
|
|
|
doNickCompletion(input);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On create
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
protected void onCreate(Bundle savedInstanceState)
|
|
|
|
{
|
|
|
|
super.onCreate(savedInstanceState);
|
|
|
|
requestWindowFeature(Window.FEATURE_NO_TITLE);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
serverId = getIntent().getExtras().getInt("serverId");
|
2011-01-15 17:17:16 -05:00
|
|
|
server = Yaaic.getInstance().getServerById(serverId);
|
2011-04-12 17:44:39 -04:00
|
|
|
|
|
|
|
// Finish activity if server does not exist anymore - See #55
|
|
|
|
if (server == null) {
|
|
|
|
this.finish();
|
|
|
|
}
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
setTitle("Yaaic - " + server.getTitle());
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
setContentView(R.layout.conversations);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-05-29 20:50:00 -04:00
|
|
|
boolean isLandscape = (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE);
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
((TextView) findViewById(R.id.title)).setText(server.getTitle());
|
2011-05-29 20:49:56 -04:00
|
|
|
|
|
|
|
EditText input = (EditText) findViewById(R.id.input);
|
|
|
|
input.setOnKeyListener(inputKeyListener);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
switcher = (ViewSwitcher) findViewById(R.id.switcher);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
dots = (ConversationSwitcher) findViewById(R.id.dots);
|
|
|
|
dots.setServer(server);
|
2010-08-27 11:25:01 -04:00
|
|
|
|
2010-03-17 16:52:51 -04:00
|
|
|
deckAdapter = new DeckAdapter();
|
2010-11-18 12:52:19 -05:00
|
|
|
deck = (Gallery) findViewById(R.id.deck);
|
2011-05-29 20:49:07 -04:00
|
|
|
deck.setOnItemSelectedListener(new ConversationSelectedListener(this, server, (TextView) findViewById(R.id.title), dots));
|
2010-11-18 12:52:19 -05:00
|
|
|
deck.setAdapter(deckAdapter);
|
|
|
|
deck.setOnItemClickListener(new ConversationClickListener(deckAdapter, switcher));
|
|
|
|
deck.setBackgroundDrawable(new NonScalingBackgroundDrawable(this, deck, R.drawable.background));
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-05-29 20:49:49 -04:00
|
|
|
Settings settings = new Settings(this);
|
|
|
|
historySize = settings.getHistorySize();
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (server.getStatus() == Status.PRE_CONNECTING) {
|
|
|
|
server.clearConversations();
|
|
|
|
deckAdapter.clearConversations();
|
2011-05-29 20:49:49 -04:00
|
|
|
server.getConversation(ServerInfo.DEFAULT_NAME).setHistorySize(historySize);
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
|
2011-01-15 17:17:16 -05:00
|
|
|
// Optimization : cache field lookups
|
2010-11-18 12:52:19 -05:00
|
|
|
Collection<Conversation> mConversations = server.getConversations();
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
for (Conversation conversation : mConversations) {
|
2011-05-29 20:49:42 -04:00
|
|
|
// Only scroll to new conversation if it was selected before
|
|
|
|
if (conversation.getStatus() == Conversation.STATUS_SELECTED) {
|
|
|
|
onNewConversation(conversation.getName());
|
|
|
|
} else {
|
|
|
|
createNewConversation(conversation.getName());
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
|
2011-05-29 20:50:00 -04:00
|
|
|
int setInputTypeFlags = 0;
|
|
|
|
if (settings.autoCorrectText()) {
|
|
|
|
setInputTypeFlags |= InputType.TYPE_TEXT_FLAG_AUTO_CORRECT;
|
|
|
|
} else {
|
|
|
|
// keep compatibility with api level 3
|
|
|
|
if ((android.os.Build.VERSION.SDK.charAt(0) - '0') >= 5) {
|
|
|
|
setInputTypeFlags |= 0x80000; // InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (settings.autoCapSentences()) {
|
|
|
|
setInputTypeFlags |= InputType.TYPE_TEXT_FLAG_CAP_SENTENCES;
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
2011-05-29 20:50:00 -04:00
|
|
|
if (isLandscape) {
|
|
|
|
/* Replace the Enter key with a smiley instead of Send, to make it
|
|
|
|
more difficult to accidentally hit send
|
|
|
|
We'd like to do this in portrait too, but wouldn't have a Send
|
|
|
|
button in that case */
|
|
|
|
setInputTypeFlags |= InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE;
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
2011-05-29 20:50:00 -04:00
|
|
|
input.setInputType(input.getInputType() | setInputTypeFlags);
|
2010-11-18 12:52:19 -05:00
|
|
|
|
|
|
|
// Create a new scrollback history
|
|
|
|
scrollback = new Scrollback();
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On resume
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void onResume()
|
|
|
|
{
|
|
|
|
// register the receivers as early as possible, otherwise we may loose a broadcast message
|
|
|
|
channelReceiver = new ConversationReceiver(server.getId(), this);
|
|
|
|
registerReceiver(channelReceiver, new IntentFilter(Broadcast.CONVERSATION_MESSAGE));
|
|
|
|
registerReceiver(channelReceiver, new IntentFilter(Broadcast.CONVERSATION_NEW));
|
|
|
|
registerReceiver(channelReceiver, new IntentFilter(Broadcast.CONVERSATION_REMOVE));
|
2011-05-29 20:49:53 -04:00
|
|
|
registerReceiver(channelReceiver, new IntentFilter(Broadcast.CONVERSATION_TOPIC));
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
serverReceiver = new ServerReceiver(this);
|
|
|
|
registerReceiver(serverReceiver, new IntentFilter(Broadcast.SERVER_UPDATE));
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
super.onResume();
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// Check if speech recognition is enabled and available
|
|
|
|
if (new Settings(this).isVoiceRecognitionEnabled()) {
|
|
|
|
PackageManager pm = getPackageManager();
|
|
|
|
Button speechButton = (Button) findViewById(R.id.speech);
|
|
|
|
List<ResolveInfo> activities = pm.queryIntentActivities(new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH), 0);
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (activities.size() != 0) {
|
|
|
|
((Button) findViewById(R.id.speech)).setOnClickListener(new SpeechClickListener(this));
|
|
|
|
speechButton.setVisibility(View.VISIBLE);
|
|
|
|
}
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
((ImageView) findViewById(R.id.status)).setImageResource(server.getStatusIcon());
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// Start service
|
2009-12-17 15:27:57 -05:00
|
|
|
Intent intent = new Intent(this, IRCService.class);
|
2010-03-29 15:48:23 -04:00
|
|
|
intent.setAction(IRCService.ACTION_FOREGROUND);
|
2010-03-21 14:57:30 -04:00
|
|
|
startService(intent);
|
2009-12-17 15:27:57 -05:00
|
|
|
bindService(intent, this, 0);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (!server.isConnected()) {
|
2011-01-15 17:17:16 -05:00
|
|
|
((EditText) findViewById(R.id.input)).setEnabled(false);
|
2010-11-18 12:52:19 -05:00
|
|
|
} else {
|
2011-01-15 17:17:16 -05:00
|
|
|
((EditText) findViewById(R.id.input)).setEnabled(true);
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Optimization - cache field lookup
|
|
|
|
Collection<Conversation> mConversations = server.getConversations();
|
|
|
|
MessageListAdapter mAdapter;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// Fill view with messages that have been buffered while paused
|
|
|
|
for (Conversation conversation : mConversations) {
|
2011-05-29 20:47:18 -04:00
|
|
|
mAdapter = deckAdapter.getItemAdapter(conversation.getName());
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (mAdapter != null) {
|
|
|
|
mAdapter.addBulkMessages(conversation.getBuffer());
|
|
|
|
conversation.clearBuffer();
|
|
|
|
}
|
2011-05-29 20:49:07 -04:00
|
|
|
|
|
|
|
// Clear new message notifications for the selected conversation
|
|
|
|
if (conversation.getStatus() == Conversation.STATUS_SELECTED && conversation.getNewMentions() > 0) {
|
|
|
|
Intent ackIntent = new Intent(this, IRCService.class);
|
|
|
|
ackIntent.setAction(IRCService.ACTION_ACK_NEW_MENTIONS);
|
2011-06-05 05:33:25 -04:00
|
|
|
ackIntent.putExtra(IRCService.EXTRA_ACK_SERVERID, serverId);
|
2011-05-29 20:49:07 -04:00
|
|
|
ackIntent.putExtra(IRCService.EXTRA_ACK_CONVTITLE, conversation.getName());
|
|
|
|
startService(ackIntent);
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// Join channel that has been selected in JoinActivity (onActivityResult())
|
|
|
|
if (joinChannelBuffer != null) {
|
|
|
|
new Thread() {
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void run() {
|
|
|
|
binder.getService().getConnection(serverId).joinChannel(joinChannelBuffer);
|
|
|
|
joinChannelBuffer = null;
|
|
|
|
}
|
|
|
|
}.start();
|
|
|
|
}
|
2011-05-29 20:49:07 -04:00
|
|
|
|
|
|
|
server.setIsForeground(true);
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On Pause
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public void onPause()
|
|
|
|
{
|
|
|
|
super.onPause();
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-05-29 20:49:07 -04:00
|
|
|
server.setIsForeground(false);
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (binder != null && binder.getService() != null) {
|
|
|
|
binder.getService().checkServiceStatus();
|
|
|
|
}
|
|
|
|
|
|
|
|
unbindService(this);
|
|
|
|
unregisterReceiver(channelReceiver);
|
|
|
|
unregisterReceiver(serverReceiver);
|
|
|
|
}
|
|
|
|
|
2011-05-29 20:49:46 -04:00
|
|
|
/**
|
|
|
|
* On save instance state (e.g. before a configuration change)
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
protected void onSaveInstanceState(Bundle outState)
|
|
|
|
{
|
|
|
|
super.onSaveInstanceState(outState);
|
|
|
|
|
|
|
|
if (deckAdapter.isSwitched()) {
|
|
|
|
outState.putBoolean("isSwitched", deckAdapter.isSwitched());
|
|
|
|
outState.putString("switchedName", deckAdapter.getSwitchedName());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On restore instance state (e.g. after a configuration change)
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
protected void onRestoreInstanceState(Bundle inState)
|
|
|
|
{
|
|
|
|
super.onRestoreInstanceState(inState);
|
|
|
|
|
|
|
|
if (inState.getBoolean("isSwitched")) {
|
|
|
|
deckAdapter.setSwitched(inState.getString("switchedName"), null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On service connected
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onServiceConnected(ComponentName name, IBinder service)
|
|
|
|
{
|
|
|
|
this.binder = (IRCBinder) service;
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// connect to irc server if connect has been requested
|
|
|
|
if (server.getStatus() == Status.PRE_CONNECTING && getIntent().hasExtra("connect")) {
|
|
|
|
server.setStatus(Status.CONNECTING);
|
|
|
|
binder.connect(server);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On service disconnected
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onServiceDisconnected(ComponentName name)
|
|
|
|
{
|
|
|
|
this.binder = null;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On options menu requested
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean onCreateOptionsMenu(Menu menu)
|
|
|
|
{
|
|
|
|
super.onCreateOptionsMenu(menu);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
// inflate from xml
|
|
|
|
MenuInflater inflater = getMenuInflater();
|
|
|
|
inflater.inflate(R.menu.conversations, menu);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On prepare options menu
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean onPrepareOptionsMenu(Menu menu)
|
|
|
|
{
|
|
|
|
menu.getItem(0).setEnabled(server.isConnected()); // join
|
|
|
|
menu.getItem(1).setEnabled(server.isConnected()); // users
|
|
|
|
menu.getItem(2).setEnabled(server.isConnected()); // close
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On menu item selected
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean onMenuItemSelected(int featureId, MenuItem item)
|
|
|
|
{
|
|
|
|
switch (item.getItemId()) {
|
|
|
|
case R.id.disconnect:
|
|
|
|
server.setStatus(Status.DISCONNECTED);
|
|
|
|
binder.getService().getConnection(serverId).quitServer();
|
|
|
|
server.clearConversations();
|
|
|
|
setResult(RESULT_OK);
|
|
|
|
finish();
|
|
|
|
break;
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
case R.id.close:
|
|
|
|
Conversation conversationToClose = deckAdapter.getItem(deck.getSelectedItemPosition());
|
|
|
|
// Make sure we part a channel when closing the channel conversation
|
|
|
|
if (conversationToClose.getType() == Conversation.TYPE_CHANNEL) {
|
|
|
|
binder.getService().getConnection(serverId).partChannel(conversationToClose.getName());
|
|
|
|
}
|
|
|
|
else if (conversationToClose.getType() == Conversation.TYPE_QUERY) {
|
|
|
|
server.removeConversation(conversationToClose.getName());
|
|
|
|
onRemoveConversation(conversationToClose.getName());
|
|
|
|
} else {
|
|
|
|
Toast.makeText(this, getResources().getString(R.string.close_server_window), Toast.LENGTH_SHORT).show();
|
|
|
|
}
|
|
|
|
break;
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
case R.id.join:
|
|
|
|
startActivityForResult(new Intent(this, JoinActivity.class), REQUEST_CODE_JOIN);
|
|
|
|
break;
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
case R.id.users:
|
|
|
|
Conversation conversationForUserList = deckAdapter.getItem(deck.getSelectedItemPosition());
|
|
|
|
if (conversationForUserList.getType() == Conversation.TYPE_CHANNEL) {
|
|
|
|
Intent intent = new Intent(this, UsersActivity.class);
|
|
|
|
intent.putExtra(
|
|
|
|
Extra.USERS,
|
|
|
|
binder.getService().getConnection(server.getId()).getUsersAsStringArray(
|
|
|
|
conversationForUserList.getName()
|
|
|
|
)
|
|
|
|
);
|
|
|
|
startActivityForResult(intent, REQUEST_CODE_USERS);
|
|
|
|
} else {
|
|
|
|
Toast.makeText(this, getResources().getString(R.string.only_usable_from_channel), Toast.LENGTH_SHORT).show();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
return true;
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* Get server object assigned to this activity
|
|
|
|
*
|
|
|
|
* @return the server object
|
|
|
|
*/
|
|
|
|
public Server getServer()
|
|
|
|
{
|
|
|
|
return server;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On conversation message
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onConversationMessage(String target)
|
|
|
|
{
|
|
|
|
Conversation conversation = server.getConversation(target);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (conversation == null) {
|
|
|
|
// In an early state it can happen that the conversation object
|
|
|
|
// is not created yet.
|
|
|
|
return;
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-05-29 20:47:18 -04:00
|
|
|
MessageListAdapter adapter = deckAdapter.getItemAdapter(target);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
while(conversation.hasBufferedMessages()) {
|
|
|
|
Message message = conversation.pollBufferedMessage();
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-03-15 23:26:17 -04:00
|
|
|
if (adapter != null && message != null) {
|
2010-11-18 12:52:19 -05:00
|
|
|
adapter.addMessage(message);
|
2011-02-22 11:31:51 -05:00
|
|
|
int status;
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2011-02-22 11:31:51 -05:00
|
|
|
switch (message.getType())
|
|
|
|
{
|
|
|
|
case Message.TYPE_MISC:
|
|
|
|
status = Conversation.STATUS_MISC;
|
|
|
|
break;
|
2011-03-14 17:15:13 -04:00
|
|
|
|
2011-02-22 11:31:51 -05:00
|
|
|
default:
|
|
|
|
status = Conversation.STATUS_MESSAGE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
conversation.setStatus(status);
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
}
|
2011-02-22 11:31:51 -05:00
|
|
|
|
|
|
|
if (dots != null) {
|
|
|
|
dots.invalidate();
|
|
|
|
}
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On new conversation
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onNewConversation(String target)
|
|
|
|
{
|
2011-05-29 20:49:42 -04:00
|
|
|
createNewConversation(target);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (!deckAdapter.isSwitched()) {
|
|
|
|
// Scroll to new conversation
|
|
|
|
deck.setSelection(deckAdapter.getCount() - 1);
|
|
|
|
}
|
|
|
|
}
|
2011-05-29 20:49:42 -04:00
|
|
|
public void createNewConversation(String target)
|
|
|
|
{
|
|
|
|
deckAdapter.addItem(server.getConversation(target));
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On conversation remove
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onRemoveConversation(String target)
|
|
|
|
{
|
|
|
|
deckAdapter.removeItem(target);
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (deckAdapter.isSwitched()) {
|
|
|
|
switcher.showNext();
|
|
|
|
switcher.removeView(deckAdapter.getSwitchedView());
|
|
|
|
deckAdapter.setSwitched(null, null);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-29 20:49:53 -04:00
|
|
|
/**
|
|
|
|
* On topic change
|
|
|
|
*/
|
|
|
|
public void onTopicChanged(String target)
|
|
|
|
{
|
|
|
|
String selected = server.getSelectedConversation();
|
|
|
|
if (selected.equals(target)) {
|
|
|
|
// onTopicChanged is only called for channels
|
|
|
|
Channel channel = (Channel) server.getConversation(selected);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
sb.append(server.getTitle() + " - " + channel.getName());
|
|
|
|
if (!(channel.getTopic()).equals(""))
|
|
|
|
sb.append(" - " + channel.getTopic());
|
|
|
|
((TextView) findViewById(R.id.title)).setText(sb.toString());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
/**
|
|
|
|
* On server status update
|
|
|
|
*/
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onStatusUpdate()
|
|
|
|
{
|
|
|
|
((ImageView) findViewById(R.id.status)).setImageResource(server.getStatusIcon());
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
EditText input = (EditText) findViewById(R.id.input);
|
|
|
|
|
|
|
|
if (server.isConnected()) {
|
2011-01-15 17:17:16 -05:00
|
|
|
input.setEnabled(true);
|
2010-11-18 12:52:19 -05:00
|
|
|
} else {
|
|
|
|
input.setEnabled(false);
|
|
|
|
|
|
|
|
if (server.getStatus() == Status.CONNECTING) {
|
|
|
|
deckAdapter.clearConversations();
|
2011-05-29 20:49:49 -04:00
|
|
|
Conversation serverInfo = server.getConversation(ServerInfo.DEFAULT_NAME);
|
|
|
|
serverInfo.setHistorySize(historySize);
|
|
|
|
deckAdapter.addItem(serverInfo);
|
2010-11-18 12:52:19 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-12 17:37:02 -04:00
|
|
|
// Service is not connected or initialized yet - See #54
|
|
|
|
if (binder == null || binder.getService() == null || binder.getService().getSettings() == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
if (!binder.getService().getSettings().isReconnectEnabled()) {
|
|
|
|
AlertDialog.Builder builder = new AlertDialog.Builder(this);
|
|
|
|
builder.setMessage(getResources().getString(R.string.reconnect_after_disconnect, server.getTitle()))
|
|
|
|
.setCancelable(false)
|
|
|
|
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
|
|
binder.getService().getConnection(server.getId()).setAutojoinChannels(
|
|
|
|
server.getCurrentChannelNames()
|
|
|
|
);
|
|
|
|
server.clearConversations();
|
|
|
|
deckAdapter.clearConversations();
|
2011-05-29 20:49:49 -04:00
|
|
|
Conversation serverInfo = server.getConversation(ServerInfo.DEFAULT_NAME);
|
|
|
|
serverInfo.setHistorySize(historySize);
|
|
|
|
deckAdapter.addItem(serverInfo);
|
2010-11-18 12:52:19 -05:00
|
|
|
binder.connect(server);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.setNegativeButton(getString(R.string.negative_button), new DialogInterface.OnClickListener() {
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void onClick(DialogInterface dialog, int id) {
|
|
|
|
dialog.cancel();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
AlertDialog alert = builder.create();
|
|
|
|
alert.show();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On key down
|
|
|
|
*
|
|
|
|
* XXX: As we only track the back key: Android >= 2.0 will call a method called onBackPressed()
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public boolean onKeyDown(int keyCode, KeyEvent event)
|
|
|
|
{
|
|
|
|
if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {
|
|
|
|
if (deckAdapter.isSwitched()) {
|
2011-05-29 20:47:18 -04:00
|
|
|
MessageListView canvas = (MessageListView) deckAdapter.getView(deckAdapter.getPositionByName(deckAdapter.getSwitchedName()), null, switcher);
|
2011-05-29 20:49:46 -04:00
|
|
|
canvas.setSwitched(false);
|
2010-11-18 12:52:19 -05:00
|
|
|
deckAdapter.setSwitched(null, null);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return super.onKeyDown(keyCode, event);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On activity result
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
protected void onActivityResult(int requestCode, int resultCode, Intent data)
|
|
|
|
{
|
|
|
|
if (resultCode != RESULT_OK) {
|
|
|
|
// ignore other result codes
|
|
|
|
return;
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
switch (requestCode) {
|
|
|
|
case REQUEST_CODE_SPEECH:
|
|
|
|
ArrayList<String> matches = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
|
2011-01-15 17:17:16 -05:00
|
|
|
if (matches.size() > 0) {
|
|
|
|
((EditText) findViewById(R.id.input)).setText(matches.get(0));
|
2010-11-18 12:52:19 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case REQUEST_CODE_JOIN:
|
|
|
|
joinChannelBuffer = data.getExtras().getString("channel");
|
|
|
|
break;
|
|
|
|
case REQUEST_CODE_USERS:
|
|
|
|
Intent intent = new Intent(this, UserActivity.class);
|
|
|
|
intent.putExtra(Extra.USER, data.getStringExtra(Extra.USER));
|
|
|
|
startActivityForResult(intent, REQUEST_CODE_USER);
|
|
|
|
break;
|
|
|
|
case REQUEST_CODE_NICK_COMPLETION:
|
2011-05-29 20:49:56 -04:00
|
|
|
insertNickCompletion((EditText) findViewById(R.id.input), data.getExtras().getString(Extra.USER));
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
|
|
|
case REQUEST_CODE_USER:
|
|
|
|
final int actionId = data.getExtras().getInt(Extra.ACTION);
|
|
|
|
final String nickname = data.getExtras().getString(Extra.USER);
|
|
|
|
final IRCConnection connection = binder.getService().getConnection(server.getId());
|
|
|
|
final String conversation = server.getSelectedConversation();
|
2011-02-05 10:04:22 -05:00
|
|
|
final Handler handler = new Handler();
|
2010-11-18 12:52:19 -05:00
|
|
|
|
|
|
|
// XXX: Implement me - The action should be handled after onResume()
|
|
|
|
// to catch the broadcasts... now we just wait a second
|
|
|
|
// Yes .. that's very ugly - we need some kind of queue that is handled after onResume()
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
new Thread() {
|
2011-01-15 17:17:16 -05:00
|
|
|
@Override
|
2010-11-18 12:52:19 -05:00
|
|
|
public void run() {
|
|
|
|
try {
|
|
|
|
Thread.sleep(1000);
|
|
|
|
} catch (InterruptedException e) {
|
|
|
|
// Do nothing
|
|
|
|
}
|
2011-01-15 17:17:16 -05:00
|
|
|
|
2011-02-05 10:04:22 -05:00
|
|
|
String nicknameWithoutPrefix = nickname;
|
|
|
|
|
|
|
|
while (
|
|
|
|
nicknameWithoutPrefix.startsWith("@") ||
|
|
|
|
nicknameWithoutPrefix.startsWith("+") ||
|
|
|
|
nicknameWithoutPrefix.startsWith(".") ||
|
|
|
|
nicknameWithoutPrefix.startsWith("%")
|
|
|
|
) {
|
|
|
|
// Strip prefix(es) now
|
|
|
|
nicknameWithoutPrefix = nicknameWithoutPrefix.substring(1);
|
|
|
|
}
|
|
|
|
|
2010-11-18 12:52:19 -05:00
|
|
|
switch (actionId) {
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_REPLY:
|
|
|
|
final String replyText = nicknameWithoutPrefix + ": ";
|
|
|
|
handler.post(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
EditText input = (EditText) findViewById(R.id.input);
|
|
|
|
input.setText(replyText);
|
|
|
|
input.setSelection(replyText.length());
|
|
|
|
}
|
|
|
|
});
|
|
|
|
break;
|
|
|
|
case User.ACTION_QUERY:
|
|
|
|
Conversation query = server.getConversation(nicknameWithoutPrefix);
|
|
|
|
if (query == null) {
|
|
|
|
// Open a query if there's none yet
|
|
|
|
query = new Query(nicknameWithoutPrefix);
|
2011-05-29 20:49:49 -04:00
|
|
|
query.setHistorySize(binder.getService().getSettings().getHistorySize());
|
2011-03-15 18:59:49 -04:00
|
|
|
server.addConversation(query);
|
2011-02-05 10:04:22 -05:00
|
|
|
|
|
|
|
Intent intent = Broadcast.createConversationIntent(
|
|
|
|
Broadcast.CONVERSATION_NEW,
|
|
|
|
server.getId(),
|
|
|
|
nicknameWithoutPrefix
|
|
|
|
);
|
|
|
|
binder.getService().sendBroadcast(intent);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case User.ACTION_OP:
|
|
|
|
connection.op(conversation, nicknameWithoutPrefix);
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_DEOP:
|
|
|
|
connection.deOp(conversation, nicknameWithoutPrefix);
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_VOICE:
|
|
|
|
connection.voice(conversation, nicknameWithoutPrefix);
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_DEVOICE:
|
|
|
|
connection.deVoice(conversation, nicknameWithoutPrefix);
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_KICK:
|
|
|
|
connection.kick(conversation, nicknameWithoutPrefix);
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
2011-02-05 10:04:22 -05:00
|
|
|
case User.ACTION_BAN:
|
|
|
|
connection.ban(conversation, nicknameWithoutPrefix + "!*@*");
|
2010-11-18 12:52:19 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}.start();
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-05-29 20:49:56 -04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a message in this conversation
|
|
|
|
*
|
|
|
|
* @param text The text of the message
|
|
|
|
*/
|
|
|
|
private void sendMessage(String text) {
|
|
|
|
if (text.equals("")) {
|
|
|
|
// ignore empty messages
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!server.isConnected()) {
|
|
|
|
Message message = new Message(getString(R.string.message_not_connected));
|
|
|
|
message.setColor(Message.COLOR_RED);
|
|
|
|
message.setIcon(R.drawable.error);
|
|
|
|
server.getConversation(server.getSelectedConversation()).addMessage(message);
|
|
|
|
onConversationMessage(server.getSelectedConversation());
|
|
|
|
}
|
|
|
|
|
|
|
|
scrollback.addMessage(text);
|
|
|
|
|
|
|
|
Conversation conversation = deckAdapter.getItem(deck.getSelectedItemPosition());
|
|
|
|
|
|
|
|
if (conversation != null) {
|
|
|
|
if (!text.trim().startsWith("/")) {
|
|
|
|
if (conversation.getType() != Conversation.TYPE_SERVER) {
|
|
|
|
String nickname = binder.getService().getConnection(serverId).getNick();
|
|
|
|
//conversation.addMessage(new Message("<" + nickname + "> " + text));
|
|
|
|
conversation.addMessage(new Message(text, nickname));
|
|
|
|
binder.getService().getConnection(serverId).sendMessage(conversation.getName(), text);
|
|
|
|
} else {
|
|
|
|
Message message = new Message(getString(R.string.chat_only_form_channel));
|
|
|
|
message.setColor(Message.COLOR_YELLOW);
|
|
|
|
message.setIcon(R.drawable.warning);
|
|
|
|
conversation.addMessage(message);
|
|
|
|
}
|
|
|
|
onConversationMessage(conversation.getName());
|
|
|
|
} else {
|
|
|
|
CommandParser.getInstance().parse(text, server, conversation, binder.getService());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Complete a nick in the input line
|
|
|
|
*/
|
|
|
|
private void doNickCompletion(EditText input) {
|
|
|
|
String text = input.getText().toString();
|
|
|
|
|
|
|
|
if (text.length() <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
String[] tokens = text.split("[\\s,.-]+");
|
|
|
|
|
|
|
|
if (tokens.length <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
String word = tokens[tokens.length - 1].toLowerCase();
|
|
|
|
tokens[tokens.length - 1] = null;
|
|
|
|
|
|
|
|
int begin = input.getSelectionStart();
|
|
|
|
int end = input.getSelectionEnd();
|
|
|
|
int cursor = Math.min(begin, end);
|
|
|
|
int sel_end = Math.max(begin, end);
|
|
|
|
|
|
|
|
boolean in_selection = (cursor != sel_end);
|
|
|
|
|
|
|
|
if (in_selection) {
|
|
|
|
word = text.substring(cursor, sel_end);
|
|
|
|
} else {
|
|
|
|
// use the word at the curent cursor position
|
|
|
|
while(true) {
|
|
|
|
cursor -= 1;
|
|
|
|
if (cursor <= 0 || text.charAt(cursor) == ' ') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cursor < 0) {
|
|
|
|
cursor = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (text.charAt(cursor) == ' ') {
|
|
|
|
cursor += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
sel_end = text.indexOf(' ', cursor);
|
|
|
|
|
|
|
|
if (sel_end == -1) {
|
|
|
|
sel_end = text.length();
|
|
|
|
}
|
|
|
|
|
|
|
|
word = text.substring(cursor, sel_end);
|
|
|
|
}
|
|
|
|
// Log.d("Yaaic", "Trying to complete nick: " + word);
|
|
|
|
|
|
|
|
Conversation conversationForUserList = deckAdapter.getItem(deck.getSelectedItemPosition());
|
|
|
|
|
|
|
|
String[] users = null;
|
|
|
|
|
|
|
|
if (conversationForUserList.getType() == Conversation.TYPE_CHANNEL) {
|
|
|
|
users = binder.getService().getConnection(server.getId()).getUsersAsStringArray(
|
|
|
|
conversationForUserList.getName()
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
// go through users and add matches
|
|
|
|
if (users != null) {
|
|
|
|
List<Integer> result = new ArrayList<Integer>();
|
|
|
|
|
|
|
|
for (int i = 0; i < users.length; i++) {
|
|
|
|
if (users[i].toLowerCase().startsWith(word)) {
|
|
|
|
result.add(Integer.valueOf(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (result.size() == 1) {
|
|
|
|
input.setSelection(cursor, sel_end);
|
|
|
|
insertNickCompletion(input, users[result.get(0).intValue()]);
|
|
|
|
} else if (result.size() > 0) {
|
|
|
|
Intent intent = new Intent(this, UsersActivity.class);
|
|
|
|
String[] extra = new String[result.size()];
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
for (Integer n : result) {
|
|
|
|
extra[i++] = users[n.intValue()];
|
|
|
|
}
|
|
|
|
|
|
|
|
input.setSelection(cursor, sel_end);
|
|
|
|
intent.putExtra(Extra.USERS, extra);
|
|
|
|
startActivityForResult(intent, REQUEST_CODE_NICK_COMPLETION);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Insert a given nick completion into the input line
|
|
|
|
*
|
|
|
|
* @param input The input line widget, with the incomplete nick selected
|
|
|
|
* @param nick The completed nick
|
|
|
|
*/
|
|
|
|
private void insertNickCompletion(EditText input, String nick) {
|
|
|
|
int start = input.getSelectionStart();
|
|
|
|
int end = input.getSelectionEnd();
|
|
|
|
|
|
|
|
if (start == 0) {
|
|
|
|
nick += ":";
|
|
|
|
}
|
|
|
|
|
|
|
|
nick += " ";
|
|
|
|
input.getText().replace(start, end, nick, 0, nick.length());
|
|
|
|
// put cursor after inserted text
|
|
|
|
input.setSelection(start + nick.length());
|
|
|
|
input.post(new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
// make the softkeyboard come up again (only if no hw keyboard is attached)
|
|
|
|
EditText input = (EditText) findViewById(R.id.input);
|
|
|
|
openSoftKeyboard(input);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
input.requestFocus();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Open the soft keyboard (helper function)
|
|
|
|
*/
|
|
|
|
private void openSoftKeyboard(View view) {
|
|
|
|
((InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)).showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
|
|
|
|
}
|
2009-12-17 15:27:57 -05:00
|
|
|
}
|