Subversion Repositories Code-Repo

package ioio.debugger;

import java.util.ArrayList;

import ioio.lib.api.IOIO;

import ioio.lib.api.IOIOFactory;

import ioio.lib.api.exception.ConnectionLostException;

import ioio.lib.api.exception.IncompatibilityException;

import android.app.Activity;

import android.content.Context;

import android.content.Intent;

import android.content.SharedPreferences;

import android.os.Bundle;

import android.os.Handler;

import android.preference.PreferenceManager;

import android.view.ContextMenu;

import android.view.ContextMenu.ContextMenuInfo;

import android.view.Menu;

import android.view.MenuInflater;

import android.view.MenuItem;

import android.view.View;

import android.view.ViewGroup;

import android.widget.LinearLayout;

import android.widget.ProgressBar;

import android.widget.TextView;

import android.widget.Toast;

public class IOIODebuggerActivity extends Activity {

	// Static IOIO instance so other activities can access it

	private static IOIO _IOIOInstance;

	private static ArrayList<Integer> _openedPins = new ArrayList<Integer>();

	// Static variable for passing ViewWidget classes between activities

	private static ViewWidget retClass;

	// Holds the selected view when the context menu is brought up

	private static View currentlySelectedView;

	// Resources for allocating new ViewWidgets

	private static Context _context;

	public static ViewGroup _viewGroupGraphTextWidget;

	public static ViewGroup _viewGroupToggleTextWidget;

	public static ViewGroup _viewGroupSimpleTextWidget;

	// List of all view widgets to display

	ArrayList<ViewWidget> _viewList = new ArrayList<ViewWidget>();

	private static Boolean _connected = false;

	private static Handler _handler = new Handler();

	private Boolean _connectionReset = true;

	private Thread _connectionMonitor;

	private TextView _status;

	private TextView _statusServer;

	private LinearLayout _mainLayout;

	private LinearLayout _rootLayout;

	private ProgressBar _statusProgress;

	// Identifiers for started activities

	static final int ACTIVITY_INPUT_ANALOG		= 0;

	static final int ACTIVITY_INPUT_DIGITAL		= 1;

	static final int ACTIVITY_INPUT_PULSE		= 2;

	static final int ACTIVITY_OUTPUT_DIGITAL	= 3;

	static final int ACTIVITY_OUTPUT_PULSE		= 4;

	// Connection manager to the server

	private static NetworkClientConnectionHandler _networkMgr;

	@Override

	public boolean onCreateOptionsMenu(Menu menu) {

		MenuInflater inflater = getMenuInflater();

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

	    return true;

	}

	@Override

	public boolean onOptionsItemSelected(MenuItem item) {

	    // Handle item selection

		if (item.getItemId() != R.id.menuOptions && 

				item.getItemId() != R.id.menuShowPinDetails && 

				item.getItemId() != R.id.menuConnect &&

				item.getItemId() != R.id.menuDisconnectFromServer &&

				!_connected) {

			Toast.makeText(this, "IOIO board not connected", Toast.LENGTH_SHORT).show();

			return true;

		}

	    switch (item.getItemId()) {

	    case R.id.addIA:

    		// Show activity to add new monitoring instance

    		startActivityForResult(new Intent(this, AddIAActivity.class), ACTIVITY_INPUT_ANALOG);

	    	return true;

	    case R.id.addID:

	    	// Show activity to add new monitoring instance

	    	startActivityForResult(new Intent(this, AddIDActivity.class), ACTIVITY_INPUT_DIGITAL);

	    	return true;

	    case R.id.addOD:

	    	// Show activity to add new monitoring instance

	    	startActivityForResult(new Intent(this, AddODActivity.class), ACTIVITY_OUTPUT_DIGITAL);

	    	return true;

	    case R.id.menuOptions:

	    	// Show options/preferences menu

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

	        return true;

	    case R.id.menuShowPinDetails:

	    	// Pullup a list of pin and their details

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

	    	return true;

	    case R.id.menuHardReset:

	    	hardReset();

	    	return true;

	    case R.id.menuResetMonitor:

	    	// Send command to clear all temp stored data

	    	clearAllMonitoredData();

	    	return true;

	    case R.id.menuDisconnectFromServer:

	    	// Disconnect from the server if connected

	    	if (_networkMgr.connectedOk())

	    		_networkMgr.disconnectFromServer();

	    	return true;

	    case R.id.menuPauseAll:

	    	pauseAll();

	    	return true;

	    case R.id.menuResumeAll:

	    	resumeAll();

	    	return true;

	    case R.id.menuConnect:

	    	// Initiate connection to Netty server

	    	connectToServer();

	    	return true;

	    default:

	        return super.onOptionsItemSelected(item);

	    }

	}

	@Override

	/** Create a context menu that comes up on selection of a view */

	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {

		super.onCreateContextMenu(menu, v, menuInfo);

		MenuInflater inflater = getMenuInflater();

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

		currentlySelectedView = v;

	}

	@Override

	public boolean onContextItemSelected(MenuItem item) {

		ViewWidget vw;

		// Operates on the individual widget views depending on the option selected

		switch (item.getItemId()) {

		case R.id.menuContextPause:

			stopViewWidget(currentlySelectedView);

			return true;

		case R.id.menuContextResume:

			startViewWidget(currentlySelectedView);

			return true;

		case R.id.menuContextRemove:

			removeViewWidget(currentlySelectedView);

			return true;

		case R.id.menuContextMoveDown:

			// Find the selected view

			for (int i = 0; i < _viewList.size()-1; i++) {

				vw = _viewList.get(i);

				if (vw.getView() == currentlySelectedView) {

					// Relocate the widget in the list

					_viewList.remove(i);

					_viewList.add(i+1, vw);

					// Remove view and divider after the view

					_mainLayout.removeViewAt(i*2);

					_mainLayout.removeViewAt(i*2);

					// Add a new divider

					addDivider(i*2+1);

		    		// Add the view

					_mainLayout.addView(vw.getView(), i*2+2);

					break;

				}

			}

			return true;

		case R.id.menuContextMoveUp:

			// Find the selected view

			for (int i = 1; i < _viewList.size(); i++) {

				vw = _viewList.get(i);

				if (vw.getView() == currentlySelectedView) {

					// Relocate the widget in the list

					_viewList.remove(i);

					_viewList.add(i-1, vw);

					// Remove view and divider before the view

					_mainLayout.removeViewAt(i*2);

					_mainLayout.removeViewAt(i*2-1);

					// Add a new divider

					addDivider(i*2-2);

		    		// Add the view

					_mainLayout.addView(vw.getView(), i*2-2);

					break;

				}

			}

			return true;

		default:

			return super.onContextItemSelected(item);

		}

	}

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

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

        _mainLayout = (LinearLayout)findViewById(R.id.mainLayout);

        _rootLayout = (LinearLayout)findViewById(R.id.rootLayout);

        _statusProgress = (ProgressBar)findViewById(R.id.progressStatus);

        _statusServer = new TextView(this);

    	_rootLayout.addView(_statusServer, 0);

    	_statusServer.setVisibility(8);

    	_context = getApplicationContext();

    	_viewGroupSimpleTextWidget = (ViewGroup) findViewById(R.id.layout_simpleText_root);

    	_viewGroupGraphTextWidget = (ViewGroup) findViewById(R.id.layout_graphText_root);

    	_viewGroupToggleTextWidget = (ViewGroup) findViewById(R.id.layout_toggleText_root);

    	_networkMgr = new NetworkClientConnectionHandler(this);

    	// Start connection monitoring thread for the IOIO board

        connectToIOIOBoard();

    }

    @Override

    public void onDestroy() {

    	super.onDestroy();

    	// Stop all monitoring update threads

    	for (ViewWidget vw : _viewList)

    		vw.stopThread();

    	_connectionMonitor.interrupt();

    	_IOIOInstance.disconnect();

    	_openedPins.clear();

    	_connected = false;

    	_networkMgr.stopAutoReconnect();

    	// Disconnect from server if connected

    	if (_networkMgr.isConnected())

    		_networkMgr.disconnectFromServer();

    }

    @Override

    public void onActivityResult(int requestCode, int resultCode, Intent data) {

    	if (resultCode == RESULT_CANCELED) {

    		return;

    	} else {

    		processAddWidget(requestCode);

    	}

    }

    /** Called by internal/external functions to add a widget after setting retClass 

     * 

     * @param requestCode one of the static codes from this class eg. ACTIVITY_INPUT_ANALOG

     */

    public void processAddWidget(final int requestCode) {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				if (_mainLayout.getChildCount() != 0) {

		    		// Insert a divider before each entry but not the first entry

					addDivider(_mainLayout.getChildCount());

				}

				switch (requestCode) {

				case ACTIVITY_INPUT_ANALOG:

					_mainLayout.addView(retClass.getView());

					retClass.startThread();

					_viewList.add(retClass);

					registerForContextMenu(retClass.getView());

					return;

				case ACTIVITY_INPUT_DIGITAL:

					_mainLayout.addView(retClass.getView());

					retClass.startThread();

					_viewList.add(retClass);

					registerForContextMenu(retClass.getView());

					return;

				case ACTIVITY_OUTPUT_DIGITAL:

					_mainLayout.addView(retClass.getView());

					retClass.startThread();

					_viewList.add(retClass);

					registerForContextMenu(retClass.getView());

					return;

				}

			}

		});

    }

    /** Start the server using values from shared preferences */

    private void connectToServer() {

    	// Show the server status message

    	_statusServer.setVisibility(0);

    	SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this);

    	String server = sharedPrefs.getString("pref_serverIP", "");

    	int port = Integer.parseInt(sharedPrefs.getString("pref_serverPort", "0"));

    	boolean reconnect = sharedPrefs.getBoolean("pref_serverReconnect", false);

    	int reconnectInterval = Integer.parseInt(sharedPrefs.getString("pref_serverReconnectInterval", "3000"));

    	get_networkMgr().setConnectionSettings(server, port, reconnect, reconnectInterval);

    	get_networkMgr().startConnect();

    }

    /** Change the server status message text */

    public void updateServerStatus(final String str) {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				_statusServer.setText(str);

			}

		});

    }

    /** Starts the thread that monitors the connection to the IOIO board */

    private void connectToIOIOBoard() {

    	_connectionMonitor = new Thread(new Runnable() {

			@Override

			public void run() {

				while (true) {

					try {

						// Check if a new instance of IOIO needs to be created

						// Reset is only triggered when a disconnect happens

						if (_connectionReset) {

							updateStatus("Waiting to connect to the IOIO board...");

							toggleProgressOn();

							_IOIOInstance = IOIOFactory.create();

							_connectionReset = false;

						}

						// Check if thread should keep running

						if (Thread.currentThread().isInterrupted()) {

							break;

						}

						// Attempt to connect to the IOIO board

						// If the board was disconnected, ConnectionLostException is thrown

						_IOIOInstance.waitForConnect();

						_connected = true;

						updateStatus("Connected to the IOIO board");

						toggleProgressOff();

						Thread.sleep(500);

					} catch (ConnectionLostException e) {

						// Reset the connection so reconnection attempts can be made

						_connected = false;

						_connectionReset = true;

						connectionReset();

						updateStatus("Connection to the IOIO board has be lost");

					} catch (IncompatibilityException e) {

						_connected = false;

						_connectionReset = true;

						connectionReset();

						updateStatus("Connected IOIO board is incompatible");

					} catch (InterruptedException e) {

						break;

					}

				}

			}

		});

    	_connectionMonitor.start();

    }

    /** Called when the connection to the IOIO board is reset */

    private void connectionReset() {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				// Stop all threads and remove all views

				for (ViewWidget view : _viewList) {

					view.stopThread();

					if (_networkMgr.connectedOk())

						_networkMgr.notifyRemovePin(view.getPin());

				}

				_openedPins.clear();

				_mainLayout.removeAllViews();

				_viewList.clear();

			}

		});

    }

    /** Adds a divider at location in mainLayout */

    private void addDivider(int index) {

    	View ruler = new View(this);

		ruler.setBackgroundColor(0xAAAAAAAA);

		_mainLayout.addView(ruler, index, new ViewGroup.LayoutParams( ViewGroup.LayoutParams.FILL_PARENT, 2));

    }

    private void pauseAll() {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				if (_viewList.size() != 0) {

			    	for (ViewWidget vw : _viewList) {

		    			if (vw.getThread().isAlive())

		    				vw.stopThread();

			    	}

		    	}

			}

		});

    }

    private void resumeAll() {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				if (_viewList.size() != 0) {

			    	for (ViewWidget vw : _viewList) {

		    			if (!vw.getThread().isAlive())

		    				vw.startThread();

			    	}

		    	}

			}

		});

    }

    /** Clear all stored data */

    private void clearAllMonitoredData() {

    	for (ViewWidget vw : _viewList) {

    		vw.clearData();

    	}

    }

    /**

     * A soft reset means "return everything to its initial state". 

     * This includes closing all interfaces obtained from this IOIO 

     * instance, and in turn freeing all resources. All pins (save 

     * the stat LED) will become floating inputs. All modules will 

     * be powered off. These operations are done without dropping 

     * the connection with the IOIO, thus a soft reset is very fast.

     */

//    private void softReset() {

//		try {

//			_IOIOInstance.softReset();

//		} catch (ConnectionLostException e) {

//			synchronized (_connected) {

//				_connected = false;

//				_connectionReset = true;

//				connectionReset();

//				updateStatus("Connection to the IOIO board has be lost");

//			}

//		}

//    }

    /**

     * A hard reset is exactly like physically powering off the IOIO 

     * board and powering it back on. As a result, the connection 

     * with the IOIO will drop and the IOIO instance will become 

     * disconnected and unusable. The board will perform a full reboot, 

     * including going through the bootloader sequence, i.e. an attempt 

     * to update the board's firmware will be made.

     */

    public void hardReset() {

		try {

			_IOIOInstance.hardReset();

		} catch (ConnectionLostException e) {

			_connected = false;

			_connectionReset = true;

			connectionReset();

			updateStatus("Connection to the IOIO board has be lost");

		}

    }

    private void toggleProgressOn() {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				_statusProgress.setVisibility(View.VISIBLE);

			}

		});

    }

    private void toggleProgressOff() {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

		    	_statusProgress.setVisibility(View.GONE);

			}

		});

    }

    /**

     * Updates the status label

     * 

     * @param text The string for the label to be set to

     */

    private void updateStatus(final String text) {

    	_handler.post(new Runnable() {

			@Override

			public void run() {

				_status.setText("Status: " + text);

			}

		});

    }

    /** Returns the static IOIO instance */

    public static IOIO getIOIOInstance() {

    	return _IOIOInstance;

    }

    /** Returns the context of the application */

    public static Context getContext() {

		return _context;

	}

    /** Returns the list of opened pins */

    public static ArrayList<Integer> getOpenedPins() {

    	return _openedPins;

    }

    /** Adds a pin to the list of opened pins */

    public static void addOpenedPin(Integer i) {

    	_openedPins.add(i);

    }

    /** Removes a pin from the list of opened pins */

    public static void removeOpenedPin(Integer i) {

    	_openedPins.remove(i);

    }

//    /** Returns the static retClass ViewWidget */

//	public static ViewWidget getViewWidget() {

//		return retClass;

//	}

	/** Sets the current static retClass ViewWidget */

	public static void setViewWidget(final ViewWidget retClass) {

		_handler.post(new Runnable() {

			@Override

			public void run() {

				IOIODebuggerActivity.retClass = retClass;

			}

		});

	}

	/** Returns the static NetworkClientConnectionHandler */

	public static NetworkClientConnectionHandler get_networkMgr() {

		return _networkMgr;

	}

	/** Signal all monitoring threads to send history of saved data */

	public void sendAllData() {

		for (ViewWidget vw : _viewList) {

			vw.sendDataHistory();

		}

	}

	/** Sends new data to the server */

	public static void sendData(int pin, Double[] d) {

		_networkMgr.sendData(pin, d);

	}

	/** Queries if the IOIO board is currently connected */

	public static boolean getConnected() {

		return _connected;

	}

	/** Starts the updater thread for the specified view */

	public void startViewWidget(View vw) {

		// Find the selected view

		for (ViewWidget vww : _viewList) {

			if (vww.getView() == currentlySelectedView) {

				vww.startThread();

				break;

			}

		}

	}

	/** Stops the updater thread for the specified view */

	public void stopViewWidget(View vw) {

		// Find the selected view

		for (ViewWidget vww : _viewList) {

			if (vww.getView() == currentlySelectedView) {

				vww.stopThread();

				break;

			}

		}

	}

	/** Stops the updater thread for the ViewWidget with the specified pin */

	public void stopViewWidget(int pin) {

		// Find the selected view

		for (ViewWidget vww : _viewList) {

			if (vww.getPin() == pin) {

				vww.stopThread();

				break;

			}

		}

	}

	/** Removes the ViewWidget that has the specified view */

	public void removeViewWidget(View view) {

		ViewWidget vw;

		// Find the selected view

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

			vw = _viewList.get(i);

			if (vw.getView() == view) {

				vw.stopThread();

				// If the widget to remove is the first one and there is only one

				if (i == 0 && _viewList.size() == 1) {

					_mainLayout.removeViewAt(0);

				// If the widget to remove is the first one and there is more than one

				} else if (i == 0 && _viewList.size() > 1) {

					_mainLayout.removeViewAt(0);

					_mainLayout.removeViewAt(0);

				// If the widget to remove is the last one

				} else if (i == _viewList.size()-1) {

					_mainLayout.removeViewAt(_mainLayout.getChildCount()-1);

					_mainLayout.removeViewAt(_mainLayout.getChildCount()-1);

				} else {

				// Remove the widget at the specified location

					_mainLayout.removeViewAt(i*2);

					_mainLayout.removeViewAt(i*2);

				}

				// Notify the server that a pin is being removed

				if (_networkMgr.connectedOk())

					_networkMgr.notifyRemovePin(vw.getPin());

				_viewList.remove(i);

				break;

			}

		}

	}

	/** Removes the ViewWidget with the specified pin */

	public void removeViewWidget(int pin) {

		ViewWidget vw;

		// Find the selected view

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

			vw = _viewList.get(i);

			if (vw.getPin() == pin) {

				vw.stopThread();

				// If the widget to remove is the first one and there is only one

				if (i == 0 && _viewList.size() == 1) {

					_mainLayout.removeViewAt(0);

				// If the widget to remove is the first one and there is more than one

				} else if (i == 0 && _viewList.size() > 1) {

					_mainLayout.removeViewAt(0);

					_mainLayout.removeViewAt(0);

				// If the widget to remove is the last one

				} else if (i == _viewList.size()-1) {

					_mainLayout.removeViewAt(_mainLayout.getChildCount()-1);

					_mainLayout.removeViewAt(_mainLayout.getChildCount()-1);

				} else {

				// Remove the widget at the specified location

					_mainLayout.removeViewAt(i*2);

					_mainLayout.removeViewAt(i*2);

				}

				// Notify the server that a pin is being removed

				if (_networkMgr.connectedOk())

					_networkMgr.notifyRemovePin(vw.getPin());

				_viewList.remove(i);

				break;

			}

		}

	}

}