Subversion Repositories Code-Repo

package org.vt.ece4564.latmb;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.GregorianCalendar;

import java.util.List;

import org.jboss.netty.channel.Channel;

import org.vt.ece4564.latmb.LATMBProtocol.Message;

import org.vt.ece4564.latmb.LATMBProtocol.Message.Builder;

import org.vt.ece4564.latmb.LATMBProtocol.Position;

import org.vt.ece4564.latmb.LATMBProtocol.TrackingMessage;

import org.vt.ece4564.latmb.LATMBProtocol.DateTime;

import android.app.Activity;

import android.content.Intent;

import android.content.SharedPreferences;

import android.location.Location;

import android.location.LocationListener;

import android.location.LocationManager;

import android.location.LocationProvider;

import android.os.Bundle;

import android.os.Handler;

import android.preference.PreferenceManager;

import android.util.Log;

import android.view.Menu;

import android.view.MenuInflater;

import android.view.MenuItem;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.ViewGroup;

import android.widget.Button;

import android.widget.EditText;

import android.widget.TextView;

import android.widget.Toast;

public class MessageBoardActivity extends Activity implements OnClickListener, 

		LocationListener, NetworkMessageHandler<TrackingMessage> {

	private static final String TAG = MessageBoardActivity.class.getName();

	private EditText newEntry_;

	private Button submit_;

	private TextView status_;

	private ViewGroup messageContainer_;

	private String server_;

	private int port_;

	private String username_;

	private String chatroom_;

	private boolean useGPS_;

	private boolean gpsAcquired_ = false;

	private boolean gpsChanged_ = false;

	private Handler handler_ = new Handler();

	private Boolean connected_ = false;

	private long reconnectInterval_ = 5000;

	private boolean autoReconnect_ = false;

	private double latitude_ = 0;

	private double longitude_ = 0;

	private double radius_ = 0;

	private LocationManager locationManager_;

	private ClientHandler<LATMBProtocol.TrackingMessage> msgHandler_;

	// List of messages stored locally

	private static List<LATMBMessage> storedMessages_ = new ArrayList<LATMBMessage>();

	@Override

	public boolean onCreateOptionsMenu(Menu menu) {

		// Create the menu

	    MenuInflater inflater = getMenuInflater();

	    inflater.inflate(R.menu.messagemenu, menu);

	    return true;

	}

	@Override

	public boolean onOptionsItemSelected(MenuItem item) {

	    // Handle item selection

	    switch (item.getItemId()) {

	    case R.id.menuPreferences:

	    	startActivity(new Intent(this, PreferenceActivity.class));

	        return true;

	    case R.id.menuDisconnect:

	    	disconnectFromServer();

	        return true;

	    case R.id.menuChangeChatroom:

	    	finish();

	    	return true;

	    case R.id.menuRefresh:

	    	storedMessages_.clear();

	    	getInitialMessages();

	    	return true;

	    default:

	        return super.onOptionsItemSelected(item);

	    }

	}

	@Override

	protected void onCreate(Bundle savedInstanceState) {

		super.onCreate(savedInstanceState);

		setContentView(R.layout.messageboard);

		newEntry_ = (EditText) findViewById(R.id.editMessage);

		submit_ = (Button) findViewById(R.id.buttonSubmit);

		status_ = (TextView) findViewById(R.id.textStatus);

		messageContainer_ = (ViewGroup) findViewById(R.id.messageList);

		Intent i = getIntent();

		server_ = i.getStringExtra("server");

		port_ = Integer.parseInt(i.getStringExtra("port"));

		username_ = i.getStringExtra("username");

		chatroom_ = i.getStringExtra("chatroom");

		useGPS_ = i.getBooleanExtra("gps", false);

		radius_ = i.getDoubleExtra("radius", 1);

		submit_.setOnClickListener(this);

		locationManager_ = (LocationManager) getSystemService(LOCATION_SERVICE);

	}

	@Override

	protected void onPause() {

		super.onPause();

		// Stop the GPS updater if location is used

		if (useGPS_) {

			locationManager_.removeUpdates(this);

		}

		stopAutoReconnect();

		disconnectFromServer();

	}

	@Override

	protected void onResume() {

		super.onResume();

		// Start the GPS updater if location is used

		if (useGPS_) {

			locationManager_.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this);

		}

		startAutoReconnect();

	}

	@Override

	public void onClick(View arg0) {

		// Send message if client is connected to server and location is acquired (only if gps is used)

		if ((connected_ && !useGPS_) || (connected_ && gpsAcquired_)) {

			SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

			String text = newEntry_.getText().toString();

			Calendar c = Calendar.getInstance();

			DateTime timestamp = DateTime.newBuilder()

					.setYear(c.get(Calendar.YEAR))

					.setMonth(c.get(Calendar.MONTH))

					.setDay(c.get(Calendar.DAY_OF_MONTH))

					.setHour(c.get(Calendar.HOUR_OF_DAY))

					.setMinute(c.get(Calendar.MINUTE))

					.setSecond(c.get(Calendar.SECOND))

					.build();

			// Get the expiration time from saved preferences

			int exp_days = Integer.parseInt(sharedPrefs.getString("pref_MessageExpiration_Days", "1"));

			int exp_months = Integer.parseInt(sharedPrefs.getString("pref_MessageExpiration_Months", "0"));

			int exp_hours = Integer.parseInt(sharedPrefs.getString("pref_MessageExpiration_Hours", "0"));

			int exp_minutes = Integer.parseInt(sharedPrefs.getString("pref_MessageExpiration_Minutes", "0"));

			c.add(Calendar.DAY_OF_MONTH, exp_days);

			c.add(Calendar.MONTH, exp_months);

			c.add(Calendar.HOUR_OF_DAY, exp_hours);

			c.add(Calendar.MINUTE, exp_minutes);

			DateTime expiration = DateTime.newBuilder()

					.setYear(c.get(Calendar.YEAR))

					.setMonth(c.get(Calendar.MONTH))

					.setDay(c.get(Calendar.DAY_OF_MONTH))

					.setHour(c.get(Calendar.HOUR_OF_DAY))

					.setMinute(c.get(Calendar.MINUTE))

					.setSecond(c.get(Calendar.SECOND))

					.build();

			Builder message = Message.newBuilder()

					.setMessage(text)

					.setTimestamp(timestamp)

					.setExpiration(expiration);

			if (!username_.isEmpty()) {

				message.setUsername(username_);

			}

			if (!useGPS_) {

				message.setChatroom(chatroom_);

			} else {

				Position pos = Position.newBuilder()

						.setLatitude(latitude_)

						.setLongitude(longitude_)

						.setAccuracy(0)

						.build();

				message.setRadius(radius_);

				message.setCoordinates(pos);

			}

			TrackingMessage msg = TrackingMessage.newBuilder()

					// Type 1 == New Message

					.setId(0).setType(1)

					.addMessage(message)

					.build();

			// Send the message to the server

			msgHandler_.send(msg);

			newEntry_.setText("");

		}

	}

	private boolean connectToServer(String server, int port) {

		try {

			synchronized (connected_) {

				if (connected_)

					return true;

				updateStatus("Connecting to server...");

				msgHandler_ = LATMBClient.connect(server, port);

				msgHandler_.setListener(this);

				connected_ = true;

				// Remove all currently saved messages

				storedMessages_.clear();

				if (!useGPS_) {

					getInitialMessages();

				}

				// Start the thread to check for expired messages

				startUpdaterThread();

				updateStatus("Connected to server [" + server + ":" + port + "]");

			}

			return true;

		} catch (Exception e) {

			Log.e(TAG, "Unable to connect to server", e);

			return false;

		}

	}

	private class ConnectWorker implements Runnable {

		public void run() {

			doConnect();

		}

		public void doConnect() {

			try {

				while (autoReconnect_ && !connectToServer(server_, port_)) {

					updateStatus("Attempting to reconnect to server...");

					Thread.currentThread().sleep(reconnectInterval_);

				}

			} catch (Exception e) {

				doConnect();

			}

		}

	}

	private void startAutoReconnect() {

		autoReconnect_ = true;

		ConnectWorker w = new ConnectWorker();

		Thread t = new Thread(w);

		t.start();

	}

	private void stopAutoReconnect() {

		autoReconnect_ = false;

	}

	private void disconnectFromServer() {

		synchronized (connected_) {

			connected_ = false;

			msgHandler_.disconnect();

		}

	}

	private void updateStatus(final String status) {

		handler_.post(new Runnable() {

			@Override

			public void run() {

				status_.setText(status);

			}

		});

	}

	private void startUpdaterThread() {

		Thread t = new Thread(new Runnable() {

			@Override

			public void run() {

				while (true) {

					try {

						// If a new GPS coordinate is set, pull new list of messages

						if (gpsChanged_ && gpsAcquired_) {

							storedMessages_.clear();

							getInitialMessages();

							gpsChanged_ = false;

						}

						// Refresh the display

						updateMessageUI();

						Thread.currentThread().sleep(5000);

					} catch (Exception e) {

						e.printStackTrace();

					}

				}

			}

		});

		t.start();

	}

	private void getInitialMessages() {

		Runnable r = new Runnable() {

			@Override

			public void run() {

				if (connected_) {

					Calendar c = Calendar.getInstance();

					DateTime timestamp = DateTime.newBuilder()

							.setYear(c.get(Calendar.YEAR))

							.setMonth(c.get(Calendar.MONTH))

							.setDay(c.get(Calendar.DAY_OF_MONTH))

							.setHour(c.get(Calendar.HOUR_OF_DAY))

							.setMinute(c.get(Calendar.MINUTE))

							.setSecond(c.get(Calendar.SECOND))

							.build();

					Builder message = Message.newBuilder()

							.setMessage("")

							.setTimestamp(timestamp)

							.setExpiration(timestamp);

					if (!username_.isEmpty()) {

						message.setUsername(username_);

					}

					if (!useGPS_) {

						message.setChatroom(chatroom_);

					} else {

						Position pos = Position.newBuilder()

								.setLatitude(latitude_)

								.setLongitude(longitude_)

								.setAccuracy(0)

								.build();

						message.setRadius(radius_);

						message.setCoordinates(pos);

					}

					TrackingMessage msg = TrackingMessage.newBuilder()

							// Type 0 == Initial Message

							.setId(0).setType(0)

							.addMessage(message)

							.build();

					msgHandler_.send(msg);

				}

			}

		};

		handler_.post(r);

	}

	@Override

	public void onLocationChanged(Location location) {

		latitude_ = location.getLatitude();

		longitude_ = location.getLongitude();

		if (latitude_ != 0 && longitude_ != 0) {

			gpsChanged_ = true;

			gpsAcquired_ = true;

		}

	}

	@Override

	public void onProviderDisabled(String arg0) {

		updateStatus("GPS is disabled");

		Intent intent = new Intent(android.provider.Settings.ACTION_LOCATION_SOURCE_SETTINGS);

		startActivity(intent);

	}

	@Override

	public void onProviderEnabled(String arg0) {

		updateStatus("GPS is enabled");

	}

	@Override

	public void onStatusChanged(String provider, int status, Bundle bundle) {

		switch (status) {

		case LocationProvider.OUT_OF_SERVICE:

			Toast.makeText(this, "GPS Status Changed: Out of Service", Toast.LENGTH_SHORT).show();

			break;

		case LocationProvider.TEMPORARILY_UNAVAILABLE:

			Toast.makeText(this, "GPS Status Changed: Temporarily Unavailable", Toast.LENGTH_SHORT).show();

			break;

		case LocationProvider.AVAILABLE:

			Toast.makeText(this, "GPS Status Changed: Available", Toast.LENGTH_SHORT).show();

			break;

		}

	}

	@Override

	public void received(final TrackingMessage msg) {

		Runnable r = new Runnable() {

			@Override

			public void run() {

				// Create a LATMBMessage from the TrackingMessage and store it

				List<Message> messages = msg.getMessageList();

				for (int i = 0; i < messages.size(); i++) {

					Message message = messages.get(i);

					DateTime timestamp = message.getTimestamp();

					DateTime expiration = message.getExpiration();

					LATMBMessage newEntry = new LATMBMessage();

					newEntry.setMessage(message.getMessage());

					Calendar time = new GregorianCalendar();

					time.set(timestamp.getYear(), timestamp.getMonth(), timestamp.getDay(), 

							timestamp.getHour(), timestamp.getMinute(), timestamp.getSecond());

					newEntry.setTimestamp(time);

					Calendar exp = new GregorianCalendar();

					exp.set(expiration.getYear(), expiration.getMonth(), expiration.getDay(), 

							expiration.getHour(), expiration.getMinute(), expiration.getSecond());

					newEntry.setExpiration(exp);

					if (message.hasUsername()) {

						newEntry.setUsername(message.getUsername());

					} else {

						newEntry.setUsername("Anonymous");

					}

					if (message.hasChatroom()) {

						newEntry.setChatroom(message.getChatroom());

					}

					if (message.hasCoordinates()) {

						Position coord = message.getCoordinates();

						newEntry.setLatitude(coord.getLatitude());

						newEntry.setLongitude(coord.getLongitude());

					}

					if (message.hasRadius()) {

						newEntry.setRadius(message.getRadius());

					}

					storedMessages_.add(newEntry);

				}

			}

		};

		handler_.post(r);

		updateMessageUI();

	}

	// Updates the GUI to show stored entries

	public void updateMessageUI() {

		Runnable r = new Runnable() {

			@Override

			public void run() {

				if (connected_) {

					// Show the current chatroom or the current GPS coordinates

					if (!useGPS_) {

						updateStatus("Current chatroom: " + chatroom_);

					} else {

						if (!gpsAcquired_) {

							updateStatus("Waiting for location...");

						} else {

							updateStatus("Using location (" + latitude_ + "," + longitude_ + ")");

						}

					}

				}

				removeExpiredMessages();

				messageContainer_.removeAllViews();

				// Print each message

				for (LATMBMessage message : storedMessages_) {

					Calendar time = message.getTimestamp();

					String msg = String.format("%d/%d/%d @ %d:%d:%d ~ %s\n>> %s",

							time.get(Calendar.DAY_OF_MONTH), time.get(Calendar.MONTH),

							time.get(Calendar.YEAR), time.get(Calendar.HOUR_OF_DAY),

							time.get(Calendar.MINUTE), time.get(Calendar.SECOND),

							message.getUsername(), message.getMessage());

					TextView v = new TextView(MessageBoardActivity.this);

					v.setText(msg);

					messageContainer_.addView(v);

				}

			}	

		};

		handler_.post(r);

	}

	// Removes all stored expired messages

	public void removeExpiredMessages() {

		Runnable r = new Runnable() {

			@Override

			public void run() {

				List<LATMBMessage> toRemove = new ArrayList<LATMBMessage>();

				for (LATMBMessage message : storedMessages_) {

					Calendar c = Calendar.getInstance();

					if (c.after(message.getExpiration())) {

						toRemove.add(message);

					}

				}

				for (LATMBMessage message : toRemove) {

					storedMessages_.remove(message);

				}

			}

		};

		handler_.post(r);

	}

	@Override

	public void channelException(Throwable e) {

		updateStatus("Exception occured connecting to server");

		connected_ = false;

	}

	@Override

	public void channelClosed(Channel c) {

		updateStatus("Connection to server closed");

		connected_ = false;

	}

}