| /Android Development/IOIODebugger/src/ioio/debugger/AddIAActivity.java |
|---|
| 0,0 → 1,88 |
| package ioio.debugger; |
| import android.app.Activity; |
| import android.os.Bundle; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.Spinner; |
| import android.widget.Toast; |
| public class AddIAActivity extends Activity implements OnClickListener { |
| private Spinner _spinnerPin; |
| private Spinner _spinnerFreq; |
| private Button _btnAdd; |
| private Integer pin; |
| private long freq; |
| /** Called when the activity is first created. */ |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.class_ia_activity); |
| _spinnerPin = (Spinner)findViewById(R.id.IAspinnerPin); |
| _spinnerFreq = (Spinner)findViewById(R.id.IAspinnerFreq); |
| _btnAdd = (Button)findViewById(R.id.IAbuttonAdd); |
| _btnAdd.setOnClickListener(this); |
| ArrayAdapter<CharSequence> adapterPin = ArrayAdapter.createFromResource(this, R.array.analog_pins, android.R.layout.simple_spinner_item); |
| adapterPin.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerPin.setAdapter(adapterPin); |
| ArrayAdapter<CharSequence> adapterFreq = ArrayAdapter.createFromResource(this, R.array.refresh_rate, android.R.layout.simple_spinner_item); |
| adapterFreq.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerFreq.setAdapter(adapterFreq); |
| _spinnerPin.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| String str = parent.getItemAtPosition(pos).toString(); |
| pin = Integer.parseInt(str); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| _spinnerFreq.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| String str = parent.getItemAtPosition(pos).toString(); |
| double val = Double.parseDouble(str); |
| freq = (long)(val*1000); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| } |
| @Override |
| public void onClick(View v) { |
| for (Integer i : IOIODebuggerActivity.getOpenedPins()) { |
| if (i == pin) { |
| Toast.makeText(this, "Specified pin has already been opened", Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| } |
| CreateWidget.addIA(pin, freq); |
| setResult(RESULT_OK); |
| finish(); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/AddIDActivity.java |
|---|
| 0,0 → 1,109 |
| package ioio.debugger; |
| import android.app.Activity; |
| import android.os.Bundle; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.widget.AdapterView; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.Spinner; |
| import android.widget.Toast; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| public class AddIDActivity extends Activity implements OnClickListener{ |
| private Spinner _spinnerPin; |
| private Spinner _spinnerFreq; |
| private Spinner _spinnerMode; |
| private Button _btnAdd; |
| private Integer pin; |
| private long freq; |
| private String mode; |
| /** Called when the activity is first created. */ |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.class_id_activity); |
| _spinnerPin = (Spinner)findViewById(R.id.IDspinnerPin); |
| _spinnerFreq = (Spinner)findViewById(R.id.IDspinnerFreq); |
| _spinnerMode = (Spinner)findViewById(R.id.IDspinnerMode); |
| _btnAdd = (Button)findViewById(R.id.IDbuttonAdd); |
| _btnAdd.setOnClickListener(this); |
| ArrayAdapter<CharSequence> adapterPin = ArrayAdapter.createFromResource(this, R.array.digital_pins, android.R.layout.simple_spinner_item); |
| adapterPin.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerPin.setAdapter(adapterPin); |
| ArrayAdapter<CharSequence> adapterFreq = ArrayAdapter.createFromResource(this, R.array.refresh_rate, android.R.layout.simple_spinner_item); |
| adapterFreq.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerFreq.setAdapter(adapterFreq); |
| ArrayAdapter<CharSequence> adapterMode = ArrayAdapter.createFromResource(this, R.array.digital_in_mode, android.R.layout.simple_spinner_item); |
| adapterMode.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerMode.setAdapter(adapterMode); |
| _spinnerPin.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| String str = parent.getItemAtPosition(pos).toString(); |
| pin = Integer.parseInt(str); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| _spinnerFreq.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| String str = parent.getItemAtPosition(pos).toString(); |
| double val = Double.parseDouble(str); |
| freq = (long)(val*1000); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| _spinnerMode.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| mode = parent.getItemAtPosition(pos).toString(); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| } |
| @Override |
| public void onClick(View v) { |
| for (Integer i : IOIODebuggerActivity.getOpenedPins()) { |
| if (i == pin) { |
| Toast.makeText(this, "Specified pin has already been opened", Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| } |
| CreateWidget.addID(pin, freq, mode); |
| setResult(RESULT_OK); |
| finish(); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/AddODActivity.java |
|---|
| 0,0 → 1,92 |
| package ioio.debugger; |
| import android.app.Activity; |
| import android.os.Bundle; |
| import android.view.View; |
| import android.view.View.OnClickListener; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.CheckBox; |
| import android.widget.Spinner; |
| import android.widget.Toast; |
| public class AddODActivity extends Activity implements OnClickListener { |
| private Spinner _spinnerPin; |
| private Spinner _spinnerMode; |
| private CheckBox _checkMode; |
| private Button _btnAdd; |
| private Integer pin; |
| private String mode; |
| private boolean openDrain; |
| /** Called when the activity is first created. */ |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.class_od_activity); |
| _spinnerPin = (Spinner)findViewById(R.id.ODspinnerPin); |
| _spinnerMode = (Spinner)findViewById(R.id.ODspinnerLevel); |
| _checkMode = (CheckBox)findViewById(R.id.ODopenDrainMode); |
| _btnAdd = (Button)findViewById(R.id.ODbuttonAdd); |
| _btnAdd.setOnClickListener(this); |
| ArrayAdapter<CharSequence> adapterPin = ArrayAdapter.createFromResource(this, R.array.digital_pins, android.R.layout.simple_spinner_item); |
| adapterPin.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerPin.setAdapter(adapterPin); |
| ArrayAdapter<CharSequence> adapterMode = ArrayAdapter.createFromResource(this, R.array.digital_out_mode, android.R.layout.simple_spinner_item); |
| adapterMode.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| _spinnerMode.setAdapter(adapterMode); |
| _spinnerPin.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| String str = parent.getItemAtPosition(pos).toString(); |
| pin = Integer.parseInt(str); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| _spinnerMode.setOnItemSelectedListener(new OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { |
| mode = parent.getItemAtPosition(pos).toString(); |
| } |
| @Override |
| public void onNothingSelected(AdapterView<?> arg0) { |
| // Do Nothing |
| } |
| }); |
| } |
| @Override |
| public void onClick(View v) { |
| openDrain = _checkMode.isChecked(); |
| for (Integer i : IOIODebuggerActivity.getOpenedPins()) { |
| if (i == pin) { |
| Toast.makeText(this, "Specified pin has already been opened", Toast.LENGTH_SHORT).show(); |
| return; |
| } |
| } |
| CreateWidget.addOD(pin, mode, openDrain); |
| setResult(RESULT_OK); |
| finish(); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/CreateWidget.java |
|---|
| 0,0 → 1,290 |
| package ioio.debugger; |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.preference.PreferenceManager; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.widget.CompoundButton; |
| import android.widget.CompoundButton.OnCheckedChangeListener; |
| import android.widget.ToggleButton; |
| import ioio.lib.api.AnalogInput; |
| import ioio.lib.api.DigitalInput; |
| import ioio.lib.api.DigitalOutput; |
| import ioio.lib.api.IOIO; |
| import ioio.lib.api.exception.ConnectionLostException; |
| public class CreateWidget { |
| public static void addIA(final Integer pin, final long freq) { |
| if (!IOIODebuggerActivity.getConnected()) |
| return; |
| Context ctx = IOIODebuggerActivity.getContext(); |
| LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| View v = inflater.inflate(R.layout.view_graph_text_widget, IOIODebuggerActivity._viewGroupGraphTextWidget); |
| final ViewWidgetGraphText viewWidget = new ViewWidgetGraphText(); |
| SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(ctx); |
| viewWidget.setView(v, false, Integer.parseInt(sharedPrefs.getString("pref_graphLength", "100"))); |
| final NetworkClientConnectionHandler networkMgr = IOIODebuggerActivity.get_networkMgr(); |
| final Double[] data = new Double[1]; |
| Runnable r = new Runnable() { |
| @Override |
| public void run() { |
| IOIODebuggerActivity.addOpenedPin(pin); |
| viewWidget.setPin(pin); |
| viewWidget.resetStopSignal(); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStartIA(pin, freq); |
| IOIO ioio = IOIODebuggerActivity.getIOIOInstance(); |
| AnalogInput in = null; |
| Float volts; |
| try { |
| in = ioio.openAnalogInput(pin); |
| viewWidget.updateStatus("Pin #" + pin.toString() + " : In : Analog : 3.3v"); |
| while (true) { |
| if (Thread.currentThread().isInterrupted()) { |
| in.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| break; |
| } |
| volts = in.getVoltage(); |
| viewWidget.updateText("Current Voltage: " + volts.toString()); |
| viewWidget.updateData((double)volts); |
| viewWidget.refreshGraph(); |
| if (networkMgr.connectedOk()) { |
| data[0] = (double)volts; |
| networkMgr.sendData(pin, data); |
| } |
| Thread.sleep(freq); |
| } |
| } catch (ConnectionLostException e) { |
| viewWidget.updateStatus("Connection Lost"); |
| } catch (InterruptedException e) { |
| if (in != null) |
| in.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| } catch (Exception e) { |
| } |
| } |
| }; |
| viewWidget.setRunnable(r); |
| IOIODebuggerActivity.setViewWidget(viewWidget); |
| } |
| public static void addID(final Integer pin, final long freq, final String mode) { |
| if (!IOIODebuggerActivity.getConnected()) |
| return; |
| Context ctx = IOIODebuggerActivity.getContext(); |
| LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| View v = inflater.inflate(R.layout.view_graph_text_widget, IOIODebuggerActivity._viewGroupGraphTextWidget); |
| final ViewWidgetGraphText viewWidget = new ViewWidgetGraphText(); |
| SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(ctx); |
| viewWidget.setView(v, true, Integer.parseInt(sharedPrefs.getString("pref_graphLength", "100"))); |
| final NetworkClientConnectionHandler networkMgr = IOIODebuggerActivity.get_networkMgr(); |
| final Double[] data = new Double[1]; |
| Runnable r = new Runnable() { |
| @Override |
| public void run() { |
| IOIODebuggerActivity.addOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStartID(pin, freq, mode); |
| viewWidget.setPin(pin); |
| viewWidget.resetStopSignal(); |
| IOIO ioio = IOIODebuggerActivity.getIOIOInstance(); |
| DigitalInput in = null; |
| viewWidget.updateStatus("Pin #" + pin.toString() + " : In : Digital : 3.3v : " + mode); |
| try { |
| if (mode.compareTo("Float") == 0) { |
| in = ioio.openDigitalInput(pin, DigitalInput.Spec.Mode.FLOATING); |
| } else if (mode.compareTo("Pull Down") == 0) { |
| in = ioio.openDigitalInput(pin, DigitalInput.Spec.Mode.PULL_DOWN); |
| } else if (mode.compareTo("Pull Up") == 0) { |
| in = ioio.openDigitalInput(pin, DigitalInput.Spec.Mode.PULL_UP); |
| } |
| while (true) { |
| if (Thread.currentThread().isInterrupted()) { |
| in.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| break; |
| } |
| if (in.read()) { |
| viewWidget.updateText("Current Input: High"); |
| viewWidget.updateData(3.3); |
| if (networkMgr.connectedOk()) { |
| data[0] = 3.3; |
| networkMgr.sendData(pin, data); |
| } |
| } else { |
| viewWidget.updateText("Current Input: Low"); |
| viewWidget.updateData(0.0); |
| if (networkMgr.connectedOk()) { |
| data[0] = 0.0; |
| networkMgr.sendData(pin, data); |
| } |
| } |
| viewWidget.refreshGraph(); |
| Thread.sleep(freq); |
| } |
| } catch (ConnectionLostException e) { |
| viewWidget.updateStatus("Connection Lost"); |
| } catch (InterruptedException e) { |
| if (in != null) |
| in.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| } |
| } |
| }; |
| viewWidget.setRunnable(r); |
| IOIODebuggerActivity.setViewWidget(viewWidget); |
| } |
| public static void addOD(final Integer pin, final String mode, final boolean openDrain) { |
| if (!IOIODebuggerActivity.getConnected()) |
| return; |
| Context ctx = IOIODebuggerActivity.getContext(); |
| LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| View v = inflater.inflate(R.layout.view_toggle_text_widget, IOIODebuggerActivity._viewGroupToggleTextWidget); |
| final ViewWidgetToggleText viewWidget = new ViewWidgetToggleText(); |
| viewWidget.setView(v); |
| ToggleButton toggle = (ToggleButton) viewWidget.getView().findViewById(R.id.layout_toggleText_toggle); |
| if (mode.compareTo("High") == 0) |
| toggle.setChecked(true); |
| else |
| toggle.setChecked(false); |
| final NetworkClientConnectionHandler networkMgr = IOIODebuggerActivity.get_networkMgr(); |
| final Double[] data = new Double[1]; |
| Runnable r = new Runnable() { |
| boolean outputHigh; |
| IOIO ioio; |
| DigitalOutput out; |
| @Override |
| public void run() { |
| IOIODebuggerActivity.addOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStartOD(pin, mode, openDrain); |
| viewWidget.setPin(pin); |
| viewWidget.resetStopSignal(); |
| if (mode.compareTo("High") == 0) |
| outputHigh = true; |
| else |
| outputHigh = false; |
| if (networkMgr.connectedOk()) { |
| if (outputHigh) |
| data[0] = 3.3; |
| else |
| data[0] = 0.0; |
| networkMgr.sendData(pin, data); |
| } |
| viewWidget.setToggle(outputHigh); |
| ioio = IOIODebuggerActivity.getIOIOInstance(); |
| try { |
| if (openDrain && outputHigh) |
| out = ioio.openDigitalOutput(pin, DigitalOutput.Spec.Mode.OPEN_DRAIN, true); |
| else if (openDrain && !outputHigh) |
| out = ioio.openDigitalOutput(pin, DigitalOutput.Spec.Mode.OPEN_DRAIN, false); |
| else if (!openDrain && outputHigh) |
| out = ioio.openDigitalOutput(pin, DigitalOutput.Spec.Mode.NORMAL, true); |
| else // (!openDrain && !outputHigh) |
| out = ioio.openDigitalOutput(pin, DigitalOutput.Spec.Mode.NORMAL, false); |
| if (openDrain) |
| viewWidget.updateStatus("Pin #" + pin.toString() + " : Out : Digital : OD : 3.3v"); |
| else |
| viewWidget.updateStatus("Pin #" + pin.toString() + " : Out : Digital : 3.3v"); |
| ToggleButton toggle = (ToggleButton)viewWidget.getView().findViewById(R.id.layout_toggleText_toggle); |
| if (toggle.isChecked()) |
| outputHigh = true; |
| else |
| outputHigh = false; |
| toggle.setOnCheckedChangeListener(new OnCheckedChangeListener() { |
| @Override |
| public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { |
| if (isChecked) { |
| outputHigh = true; |
| } else { |
| outputHigh = false; |
| } |
| if (networkMgr.connectedOk()) { |
| if (outputHigh) |
| data[0] = 3.3; |
| else |
| data[0] = 0.0; |
| networkMgr.sendData(pin, data); |
| } |
| } |
| }); |
| while (true) { |
| if (Thread.currentThread().isInterrupted()) { |
| out.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| break; |
| } |
| if (outputHigh) { |
| viewWidget.updateText("Current Output: HIGH"); |
| out.write(true); |
| } else { |
| viewWidget.updateText("Current Output: LOW"); |
| out.write(false); |
| } |
| viewWidget.setToggle(outputHigh); |
| Thread.sleep(50); |
| } |
| } catch (ConnectionLostException e) { |
| viewWidget.updateStatus("Connection Lost"); |
| } catch (InterruptedException e) { |
| if (out != null) |
| out.close(); |
| viewWidget.setStopSignal(); |
| IOIODebuggerActivity.removeOpenedPin(pin); |
| if (networkMgr.connectedOk()) |
| networkMgr.notifyStopPin(pin); |
| } catch (Exception e) { |
| } |
| } |
| }; |
| viewWidget.setRunnable(r); |
| IOIODebuggerActivity.setViewWidget(viewWidget); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/Debug Protocol Details.txt |
|---|
| 0,0 → 1,24 |
| Network Debug Protocol Message Type Details: |
| Type# Description |
| 1 General ACK_SUCCESS |
| 2 General ACK_FAILURE |
| 10 Check if connection is ok |
| 11 Connection ok response |
| 12 Connection not ok response |
| 13 Reset board (hard reset) |
| 50 Start pin |
| Type: InAnalog Pin:# Freq:# |
| Type: InDigital Pin:# Freq:# Mode:[Float/Pull Up/Pull Down] |
| Type: OutDigital Pin:# State:[Low/High] Boolean:[True/False] |
| 51 Stop pin |
| Pin:# |
| 52 Remove pin |
| Pin:# |
| 70 Send new data |
| Pin:# Data:# |
| /Android Development/IOIODebugger/src/ioio/debugger/GenericXYSeries.java |
|---|
| 0,0 → 1,53 |
| package ioio.debugger; |
| import java.util.LinkedList; |
| import com.androidplot.series.XYSeries; |
| public class GenericXYSeries implements XYSeries { |
| private int length; |
| private String title; |
| private LinkedList<Number> data; |
| public GenericXYSeries(String str, int len) { |
| title = str; |
| length = len; |
| data = new LinkedList<Number>(); |
| } |
| @Override |
| public String getTitle() { |
| return title; |
| } |
| @Override |
| public int size() { |
| return length; |
| } |
| @Override |
| public Number getX(int index) { |
| return index; |
| } |
| @Override |
| public Number getY(int index) { |
| if (index >= data.size()) |
| return 0; |
| else |
| return data.get(index); |
| } |
| public void addDataToList(Number num) { |
| if (data.size() > length) |
| data.removeFirst(); |
| data.addLast(num); |
| } |
| public void clearData() { |
| data.clear(); |
| } |
| public LinkedList<Number> getData() { |
| return data; |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/GlobalPreferenceActivity.java |
|---|
| 0,0 → 1,70 |
| package ioio.debugger; |
| import android.content.SharedPreferences; |
| import android.content.SharedPreferences.OnSharedPreferenceChangeListener; |
| import android.os.Bundle; |
| import android.preference.EditTextPreference; |
| import android.preference.PreferenceManager; |
| import android.text.InputType; |
| public class GlobalPreferenceActivity extends android.preference.PreferenceActivity implements OnSharedPreferenceChangeListener { |
| private EditTextPreference _pref_serverIP; |
| private EditTextPreference _pref_serverPort; |
| // private CheckBoxPreference _pref_serverReconnect; |
| private EditTextPreference _pref_serverReconnectInterval; |
| private EditTextPreference _pref_graphLength; |
| private SharedPreferences sharedPrefs; |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| addPreferencesFromResource(R.xml.preference); |
| _pref_serverIP = (EditTextPreference) findPreference("pref_serverIP"); |
| _pref_serverPort = (EditTextPreference) findPreference("pref_serverPort"); |
| // _pref_serverReconnect = (CheckBoxPreference) findPreference("pref_serverReconnect"); |
| _pref_serverReconnectInterval = (EditTextPreference) findPreference("pref_serverReconnectInterval"); |
| _pref_graphLength = (EditTextPreference) findPreference("pref_graphLength"); |
| sharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| } |
| @Override |
| public void onResume() { |
| super.onResume(); |
| // Set the summary text to the current value |
| _pref_serverIP.setSummary("Current Value: " + sharedPrefs.getString("pref_serverIP", "")); |
| _pref_serverPort.setSummary("Current Value: " + sharedPrefs.getString("pref_serverPort", "")); |
| _pref_serverReconnectInterval.setSummary("Current Value: " + sharedPrefs.getString("pref_serverReconnectInterval", "")); |
| _pref_graphLength.setSummary("Current Value: " + sharedPrefs.getString("pref_graphLength", "")); |
| _pref_serverPort.getEditText().setInputType(InputType.TYPE_CLASS_NUMBER); |
| _pref_graphLength.getEditText().setInputType(InputType.TYPE_CLASS_NUMBER); |
| _pref_serverReconnectInterval.getEditText().setInputType(InputType.TYPE_CLASS_NUMBER); |
| getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this); |
| } |
| @Override |
| public void onPause() { |
| super.onPause(); |
| getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this); |
| } |
| @Override |
| public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) { |
| // Change the summary text when the value is changed |
| if (key.compareTo("pref_serverIP") == 0) { |
| _pref_serverIP.setSummary("Current Value: " + sharedPreferences.getString(key, "")); |
| } else if (key.compareTo("pref_serverPort") == 0) { |
| _pref_serverPort.setSummary("Current Value: " + sharedPreferences.getString(key, "")); |
| } else if (key.compareTo("pref_serverReconnectInterval") == 0) { |
| _pref_serverReconnectInterval.setSummary("Current Value: " + sharedPreferences.getString(key, "")); |
| } else if (key.compareTo("pref_graphLength") == 0) { |
| _pref_graphLength.setSummary("Current Value: " + sharedPrefs.getString("pref_graphLength", "")); |
| } |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/IOIODebuggerActivity.java |
|---|
| 0,0 → 1,663 |
| 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; |
| } |
| } |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkClient.java |
|---|
| 0,0 → 1,55 |
| /************************************************************************** |
| * Copyright 2011 Jules White |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| ***************************************************************************/ |
| package ioio.debugger; |
| import java.net.InetSocketAddress; |
| import java.util.concurrent.Executors; |
| import org.jboss.netty.bootstrap.ClientBootstrap; |
| import org.jboss.netty.channel.Channel; |
| import org.jboss.netty.channel.ChannelFuture; |
| import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory; |
| public class NetworkClient { |
| @SuppressWarnings("rawtypes") |
| public static NetworkClientHandler connect(String host, int port) throws Exception { |
| // Configure the client. |
| ClientBootstrap bootstrap = new ClientBootstrap( |
| new NioClientSocketChannelFactory( |
| Executors.newCachedThreadPool(), |
| Executors.newCachedThreadPool())); |
| // Configure the pipeline factory. |
| bootstrap.setPipelineFactory(new NetworkClientPipelineFactory()); |
| // Start the connection attempt. |
| ChannelFuture future = bootstrap.connect(new InetSocketAddress(host, port)); |
| // Wait until the connection attempt succeeds or fails. |
| Channel channel = future.awaitUninterruptibly().getChannel(); |
| if (!future.isSuccess()) { |
| future.getCause().printStackTrace(); |
| bootstrap.releaseExternalResources(); |
| return null; |
| } |
| return channel.getPipeline().get(NetworkClientHandler.class); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkClientConnectionHandler.java |
|---|
| 0,0 → 1,356 |
| package ioio.debugger; |
| import java.util.List; |
| import ioio.debugger.NetworkIOIOProtocol.Message; |
| import ioio.debugger.NetworkIOIOProtocol.Message.Builder; |
| import ioio.debugger.NetworkIOIOProtocol.TrackingMessage; |
| import org.jboss.netty.channel.Channel; |
| import android.os.Handler; |
| public class NetworkClientConnectionHandler implements NetworkMessageHandler<TrackingMessage> { |
| // Message handler for sending messages to server |
| private NetworkClientHandler<NetworkIOIOProtocol.TrackingMessage> msgHandler_; |
| private Boolean connected_ = false; |
| private boolean connectionOk_ = false; |
| private long reconnectInterval_ = 3000; |
| private boolean autoReconnect_ = false; |
| private String server_; |
| private int port_; |
| private IOIODebuggerActivity parent_; |
| private Thread connection_; |
| private Handler handler_ = new Handler(); |
| public NetworkClientConnectionHandler(IOIODebuggerActivity parent) { |
| parent_ = parent; |
| connection_ = new Thread(); |
| } |
| public void setConnectionSettings(final String server, final int port, final boolean autoReconnect, final long reconnectInterval) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| server_ = server; |
| port_ = port; |
| autoReconnect_ = autoReconnect; |
| reconnectInterval_ = reconnectInterval; |
| } |
| }); |
| } |
| @Override |
| public void channelException(Throwable e) { |
| synchronized (connected_) { |
| parent_.updateServerStatus("Exception occured contacting server"); |
| connected_ = false; |
| connectionOk_ = false; |
| } |
| } |
| @Override |
| public void channelClosed(Channel c) { |
| synchronized (connected_) { |
| parent_.updateServerStatus("Connection to server closed"); |
| connected_ = false; |
| connectionOk_ = false; |
| } |
| } |
| @Override |
| public void received(final TrackingMessage msg) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| List<Message> messageList; |
| switch(msg.getType()) { |
| case 11: |
| parent_.updateServerStatus("Connected to server [ " + server_ + " :: " + port_ + " ]"); |
| connectionOk_ = true; |
| parent_.sendAllData(); |
| break; |
| case 12: |
| parent_.updateServerStatus("Connection to server rejected. Try again?"); |
| disconnectFromServer(); |
| break; |
| case 13: |
| parent_.hardReset(); |
| break; |
| case 50: |
| messageList = msg.getMessageList(); |
| for (Message message : messageList) { |
| String type = message.getType(); |
| if (type.compareTo("InAnalog") == 0) { |
| CreateWidget.addIA(message.getPin(), message.getFreq()); |
| parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_INPUT_ANALOG); |
| } else if (type.compareTo("InDigital") == 0) { |
| CreateWidget.addID(message.getPin(), message.getFreq(), message.getMode()); |
| parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_INPUT_DIGITAL); |
| } else if (type.compareTo("OutDigital") == 0) { |
| CreateWidget.addOD(message.getPin(), message.getMode(), message.getBoolean()); |
| parent_.processAddWidget(IOIODebuggerActivity.ACTIVITY_OUTPUT_DIGITAL); |
| } |
| } |
| break; |
| case 51: |
| messageList = msg.getMessageList(); |
| for (Message message : messageList) { |
| parent_.stopViewWidget(message.getPin()); |
| } |
| break; |
| case 52: |
| messageList = msg.getMessageList(); |
| for (Message message : messageList) { |
| parent_.removeViewWidget(message.getPin()); |
| } |
| } |
| } |
| }); |
| } |
| @SuppressWarnings("unchecked") |
| public boolean connectToServer() { |
| try { |
| synchronized (connected_) { |
| if (connected_) |
| return true; |
| parent_.updateServerStatus("Connecting to server..."); |
| msgHandler_ = NetworkClient.connect(server_, port_); |
| msgHandler_.setListener(this); |
| connected_ = true; |
| // Wait a bit for the connection to finish initialization |
| Thread.sleep(500); |
| // Queries if connection is ok |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(10) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| return true; |
| } catch (Exception e) { |
| parent_.updateServerStatus("Unable to connect to server"); |
| return false; |
| } |
| } |
| private class ConnectWorker implements Runnable { |
| public void run() { |
| doConnect(); |
| } |
| public void doConnect() { |
| try { |
| if (!connectToServer()) { |
| while (autoReconnect_ && !connectToServer()) { |
| parent_.updateServerStatus("Waiting to reconnect to server..."); |
| Thread.sleep(reconnectInterval_); |
| } |
| } |
| } catch (Exception e) { |
| doConnect(); |
| } |
| } |
| } |
| public void startConnect() { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| ConnectWorker w = new ConnectWorker(); |
| connection_ = new Thread(w); |
| connection_.start(); |
| } |
| }); |
| } |
| public void stopAutoReconnect() { |
| autoReconnect_ = false; |
| } |
| public void disconnectFromServer() { |
| synchronized (connected_) { |
| connected_ = false; |
| connectionOk_ = false; |
| autoReconnect_ = false; |
| msgHandler_.disconnect(); |
| parent_.updateServerStatus("Disconnected from server"); |
| } |
| } |
| public Boolean isConnected() { |
| return connected_; |
| } |
| public boolean connectedOk() { |
| return connectionOk_; |
| } |
| public void notifyACK_Success() { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(1) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyACK_Failure() { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(2) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyStartIA(final int pin, final long freq) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| Builder message = Message.newBuilder() |
| .setPin(pin) |
| .setFreq(freq) |
| .setType("InAnalog"); |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(50) |
| .addMessage(message) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyStartID(final int pin, final long freq, final String mode) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| Builder message = Message.newBuilder() |
| .setPin(pin) |
| .setFreq(freq) |
| .setMode(mode) |
| .setType("InDigital"); |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(50) |
| .addMessage(message) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyStartOD(final int pin, final String state, final boolean openDrain) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| Builder message = Message.newBuilder() |
| .setPin(pin) |
| .setState(state) |
| .setBoolean(openDrain) |
| .setType("OutDigital"); |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(50) |
| .addMessage(message) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyStopPin(final int pin) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| Builder message = Message.newBuilder() |
| .setPin(pin); |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(51) |
| .addMessage(message) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void notifyRemovePin(final int pin) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| Builder message = Message.newBuilder() |
| .setPin(pin); |
| TrackingMessage newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(52) |
| .addMessage(message) |
| .build(); |
| msgHandler_.send(newMsg); |
| } |
| }); |
| } |
| public void sendData(final int pin, final Double[] data) { |
| handler_.post(new Runnable() { |
| @Override |
| public void run() { |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage.Builder newMsg = TrackingMessage.newBuilder() |
| .setId(0) |
| .setType(70); |
| Builder message = Message.newBuilder().setPin(pin); |
| for (double d : data) { |
| message.addData(d); |
| } |
| newMsg.addMessage(message); |
| msgHandler_.send(newMsg.build()); |
| } |
| }); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkClientHandler.java |
|---|
| 0,0 → 1,116 |
| /************************************************************************** |
| * Copyright 2011 Jules White |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| ***************************************************************************/ |
| package ioio.debugger; |
| import java.util.logging.Level; |
| import java.util.logging.Logger; |
| import org.jboss.netty.channel.Channel; |
| import org.jboss.netty.channel.ChannelEvent; |
| import org.jboss.netty.channel.ChannelFuture; |
| import org.jboss.netty.channel.ChannelFutureListener; |
| import org.jboss.netty.channel.ChannelHandlerContext; |
| import org.jboss.netty.channel.ChannelStateEvent; |
| import org.jboss.netty.channel.ExceptionEvent; |
| import org.jboss.netty.channel.MessageEvent; |
| import org.jboss.netty.channel.SimpleChannelUpstreamHandler; |
| import android.util.Log; |
| /** |
| * Handles a client-side channel. |
| * |
| * @author <a href="http://www.jboss.org/netty/">The Netty Project</a> |
| * @author <a href="http://gleamynode.net/">Trustin Lee</a> |
| * |
| * @version $Rev: 2121 $, $Date: 2010-02-02 09:38:07 +0900 (Tue, 02 Feb 2010) $ |
| */ |
| public class NetworkClientHandler<T> extends SimpleChannelUpstreamHandler { |
| private static final String TAG = NetworkClientHandler.class.getName(); |
| private NetworkMessageHandler<T> listener_; |
| private Channel channel_; |
| private static final Logger logger = Logger |
| .getLogger(NetworkClientHandler.class.getName()); |
| public void disconnect(){ |
| channel_.disconnect(); |
| } |
| @Override |
| public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e) |
| throws Exception { |
| if (e instanceof ChannelStateEvent) { |
| logger.info(e.toString()); |
| } |
| super.handleUpstream(ctx, e); |
| } |
| // @Override |
| public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) |
| throws Exception { |
| channel_ = e.getChannel(); |
| channel_.getCloseFuture().addListener(new ChannelFutureListener() { |
| @Override |
| public void operationComplete(ChannelFuture future) |
| throws Exception { |
| listener_.channelClosed(channel_); |
| } |
| }); |
| } |
| @Override |
| public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { |
| if (listener_ != null) { |
| @SuppressWarnings("unchecked") |
| T msg = (T) e.getMessage(); |
| listener_.received(msg); |
| } else { |
| System.err.println(e.getMessage()); |
| } |
| } |
| public void send(NetworkIOIOProtocol.TrackingMessage msg) { |
| channel_.write(msg); |
| } |
| @Override |
| public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) { |
| logger.log(Level.WARNING, "Unexpected exception from downstream.", |
| e.getCause()); |
| e.getChannel().close(); |
| if(listener_ != null) |
| listener_.channelException(e.getCause()); |
| else |
| Log.e(TAG, "Error communicating with server",e.getCause()); |
| } |
| public NetworkMessageHandler<T> getListener() { |
| return listener_; |
| } |
| public void setListener(NetworkMessageHandler<T> listener) { |
| listener_ = listener; |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkClientPipelineFactory.java |
|---|
| 0,0 → 1,54 |
| /************************************************************************** |
| * Copyright 2011 Jules White |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| ***************************************************************************/ |
| package ioio.debugger; |
| import static org.jboss.netty.channel.Channels.pipeline; |
| import org.jboss.netty.channel.ChannelPipeline; |
| import org.jboss.netty.channel.ChannelPipelineFactory; |
| import org.jboss.netty.handler.codec.protobuf.ProtobufDecoder; |
| import org.jboss.netty.handler.codec.protobuf.ProtobufEncoder; |
| import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder; |
| import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender; |
| /** |
| * Creates a newly configured {@link ChannelPipeline} for a new channel. |
| * |
| * @author <a href="http://www.jboss.org/netty/">The Netty Project</a> |
| * @author <a href="http://gleamynode.net/">Trustin Lee</a> |
| * |
| * @version $Rev: 2080 $, $Date: 2010-01-26 18:04:19 +0900 (Tue, 26 Jan 2010) $ |
| * |
| */ |
| public class NetworkClientPipelineFactory implements ChannelPipelineFactory { |
| public ChannelPipeline getPipeline() throws Exception { |
| ChannelPipeline pipeline = pipeline(); |
| pipeline.addLast("frameDecoder", new ProtobufVarint32FrameDecoder()); |
| pipeline.addLast("protobufDecoder", new ProtobufDecoder( |
| NetworkIOIOProtocol.TrackingMessage.getDefaultInstance())); |
| pipeline.addLast("frameEncoder", |
| new ProtobufVarint32LengthFieldPrepender()); |
| pipeline.addLast("protobufEncoder", new ProtobufEncoder()); |
| // and then business logic. |
| pipeline.addLast("handler", new NetworkClientHandler<NetworkIOIOProtocol.TrackingMessage>()); |
| return pipeline; |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkIOIOProtocol.java |
|---|
| 0,0 → 1,1591 |
| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: NetworkIOIOProtocol.proto |
| package ioio.debugger; |
| public final class NetworkIOIOProtocol { |
| private NetworkIOIOProtocol() {} |
| public static void registerAllExtensions( |
| com.google.protobuf.ExtensionRegistry registry) { |
| } |
| public interface TrackingMessageOrBuilder |
| extends com.google.protobuf.MessageOrBuilder { |
| // required int32 id = 1; |
| boolean hasId(); |
| int getId(); |
| // required int32 type = 2; |
| boolean hasType(); |
| int getType(); |
| // repeated .ioio.debugger.Message message = 3; |
| java.util.List<ioio.debugger.NetworkIOIOProtocol.Message> |
| getMessageList(); |
| ioio.debugger.NetworkIOIOProtocol.Message getMessage(int index); |
| int getMessageCount(); |
| java.util.List<? extends ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder> |
| getMessageOrBuilderList(); |
| ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder getMessageOrBuilder( |
| int index); |
| } |
| public static final class TrackingMessage extends |
| com.google.protobuf.GeneratedMessage |
| implements TrackingMessageOrBuilder { |
| // Use TrackingMessage.newBuilder() to construct. |
| private TrackingMessage(Builder builder) { |
| super(builder); |
| } |
| private TrackingMessage(boolean noInit) {} |
| private static final TrackingMessage defaultInstance; |
| public static TrackingMessage getDefaultInstance() { |
| return defaultInstance; |
| } |
| public TrackingMessage getDefaultInstanceForType() { |
| return defaultInstance; |
| } |
| public static final com.google.protobuf.Descriptors.Descriptor |
| getDescriptor() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_TrackingMessage_descriptor; |
| } |
| protected com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internalGetFieldAccessorTable() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_TrackingMessage_fieldAccessorTable; |
| } |
| private int bitField0_; |
| // required int32 id = 1; |
| public static final int ID_FIELD_NUMBER = 1; |
| private int id_; |
| public boolean hasId() { |
| return ((bitField0_ & 0x00000001) == 0x00000001); |
| } |
| public int getId() { |
| return id_; |
| } |
| // required int32 type = 2; |
| public static final int TYPE_FIELD_NUMBER = 2; |
| private int type_; |
| public boolean hasType() { |
| return ((bitField0_ & 0x00000002) == 0x00000002); |
| } |
| public int getType() { |
| return type_; |
| } |
| // repeated .ioio.debugger.Message message = 3; |
| public static final int MESSAGE_FIELD_NUMBER = 3; |
| private java.util.List<ioio.debugger.NetworkIOIOProtocol.Message> message_; |
| public java.util.List<ioio.debugger.NetworkIOIOProtocol.Message> getMessageList() { |
| return message_; |
| } |
| public java.util.List<? extends ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder> |
| getMessageOrBuilderList() { |
| return message_; |
| } |
| public int getMessageCount() { |
| return message_.size(); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message getMessage(int index) { |
| return message_.get(index); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder getMessageOrBuilder( |
| int index) { |
| return message_.get(index); |
| } |
| private void initFields() { |
| id_ = 0; |
| type_ = 0; |
| message_ = java.util.Collections.emptyList(); |
| } |
| private byte memoizedIsInitialized = -1; |
| public final boolean isInitialized() { |
| byte isInitialized = memoizedIsInitialized; |
| if (isInitialized != -1) return isInitialized == 1; |
| if (!hasId()) { |
| memoizedIsInitialized = 0; |
| return false; |
| } |
| if (!hasType()) { |
| memoizedIsInitialized = 0; |
| return false; |
| } |
| memoizedIsInitialized = 1; |
| return true; |
| } |
| public void writeTo(com.google.protobuf.CodedOutputStream output) |
| throws java.io.IOException { |
| getSerializedSize(); |
| if (((bitField0_ & 0x00000001) == 0x00000001)) { |
| output.writeInt32(1, id_); |
| } |
| if (((bitField0_ & 0x00000002) == 0x00000002)) { |
| output.writeInt32(2, type_); |
| } |
| for (int i = 0; i < message_.size(); i++) { |
| output.writeMessage(3, message_.get(i)); |
| } |
| getUnknownFields().writeTo(output); |
| } |
| private int memoizedSerializedSize = -1; |
| public int getSerializedSize() { |
| int size = memoizedSerializedSize; |
| if (size != -1) return size; |
| size = 0; |
| if (((bitField0_ & 0x00000001) == 0x00000001)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeInt32Size(1, id_); |
| } |
| if (((bitField0_ & 0x00000002) == 0x00000002)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeInt32Size(2, type_); |
| } |
| for (int i = 0; i < message_.size(); i++) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeMessageSize(3, message_.get(i)); |
| } |
| size += getUnknownFields().getSerializedSize(); |
| memoizedSerializedSize = size; |
| return size; |
| } |
| private static final long serialVersionUID = 0L; |
| @java.lang.Override |
| protected java.lang.Object writeReplace() |
| throws java.io.ObjectStreamException { |
| return super.writeReplace(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| com.google.protobuf.ByteString data) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| com.google.protobuf.ByteString data, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom(byte[] data) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| byte[] data, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom(java.io.InputStream input) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| java.io.InputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseDelimitedFrom(java.io.InputStream input) |
| throws java.io.IOException { |
| Builder builder = newBuilder(); |
| if (builder.mergeDelimitedFrom(input)) { |
| return builder.buildParsed(); |
| } else { |
| return null; |
| } |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseDelimitedFrom( |
| java.io.InputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| Builder builder = newBuilder(); |
| if (builder.mergeDelimitedFrom(input, extensionRegistry)) { |
| return builder.buildParsed(); |
| } else { |
| return null; |
| } |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| com.google.protobuf.CodedInputStream input) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.TrackingMessage parseFrom( |
| com.google.protobuf.CodedInputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input, extensionRegistry) |
| .buildParsed(); |
| } |
| public static Builder newBuilder() { return Builder.create(); } |
| public Builder newBuilderForType() { return newBuilder(); } |
| public static Builder newBuilder(ioio.debugger.NetworkIOIOProtocol.TrackingMessage prototype) { |
| return newBuilder().mergeFrom(prototype); |
| } |
| public Builder toBuilder() { return newBuilder(this); } |
| @java.lang.Override |
| protected Builder newBuilderForType( |
| com.google.protobuf.GeneratedMessage.BuilderParent parent) { |
| Builder builder = new Builder(parent); |
| return builder; |
| } |
| public static final class Builder extends |
| com.google.protobuf.GeneratedMessage.Builder<Builder> |
| implements ioio.debugger.NetworkIOIOProtocol.TrackingMessageOrBuilder { |
| public static final com.google.protobuf.Descriptors.Descriptor |
| getDescriptor() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_TrackingMessage_descriptor; |
| } |
| protected com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internalGetFieldAccessorTable() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_TrackingMessage_fieldAccessorTable; |
| } |
| // Construct using ioio.debugger.NetworkIOIOProtocol.TrackingMessage.newBuilder() |
| private Builder() { |
| maybeForceBuilderInitialization(); |
| } |
| private Builder(BuilderParent parent) { |
| super(parent); |
| maybeForceBuilderInitialization(); |
| } |
| private void maybeForceBuilderInitialization() { |
| if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { |
| getMessageFieldBuilder(); |
| } |
| } |
| private static Builder create() { |
| return new Builder(); |
| } |
| public Builder clear() { |
| super.clear(); |
| id_ = 0; |
| bitField0_ = (bitField0_ & ~0x00000001); |
| type_ = 0; |
| bitField0_ = (bitField0_ & ~0x00000002); |
| if (messageBuilder_ == null) { |
| message_ = java.util.Collections.emptyList(); |
| bitField0_ = (bitField0_ & ~0x00000004); |
| } else { |
| messageBuilder_.clear(); |
| } |
| return this; |
| } |
| public Builder clone() { |
| return create().mergeFrom(buildPartial()); |
| } |
| public com.google.protobuf.Descriptors.Descriptor |
| getDescriptorForType() { |
| return ioio.debugger.NetworkIOIOProtocol.TrackingMessage.getDescriptor(); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.TrackingMessage getDefaultInstanceForType() { |
| return ioio.debugger.NetworkIOIOProtocol.TrackingMessage.getDefaultInstance(); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.TrackingMessage build() { |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage result = buildPartial(); |
| if (!result.isInitialized()) { |
| throw newUninitializedMessageException(result); |
| } |
| return result; |
| } |
| private ioio.debugger.NetworkIOIOProtocol.TrackingMessage buildParsed() |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage result = buildPartial(); |
| if (!result.isInitialized()) { |
| throw newUninitializedMessageException( |
| result).asInvalidProtocolBufferException(); |
| } |
| return result; |
| } |
| public ioio.debugger.NetworkIOIOProtocol.TrackingMessage buildPartial() { |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage result = new ioio.debugger.NetworkIOIOProtocol.TrackingMessage(this); |
| int from_bitField0_ = bitField0_; |
| int to_bitField0_ = 0; |
| if (((from_bitField0_ & 0x00000001) == 0x00000001)) { |
| to_bitField0_ |= 0x00000001; |
| } |
| result.id_ = id_; |
| if (((from_bitField0_ & 0x00000002) == 0x00000002)) { |
| to_bitField0_ |= 0x00000002; |
| } |
| result.type_ = type_; |
| if (messageBuilder_ == null) { |
| if (((bitField0_ & 0x00000004) == 0x00000004)) { |
| message_ = java.util.Collections.unmodifiableList(message_); |
| bitField0_ = (bitField0_ & ~0x00000004); |
| } |
| result.message_ = message_; |
| } else { |
| result.message_ = messageBuilder_.build(); |
| } |
| result.bitField0_ = to_bitField0_; |
| onBuilt(); |
| return result; |
| } |
| public Builder mergeFrom(com.google.protobuf.Message other) { |
| if (other instanceof ioio.debugger.NetworkIOIOProtocol.TrackingMessage) { |
| return mergeFrom((ioio.debugger.NetworkIOIOProtocol.TrackingMessage)other); |
| } else { |
| super.mergeFrom(other); |
| return this; |
| } |
| } |
| public Builder mergeFrom(ioio.debugger.NetworkIOIOProtocol.TrackingMessage other) { |
| if (other == ioio.debugger.NetworkIOIOProtocol.TrackingMessage.getDefaultInstance()) return this; |
| if (other.hasId()) { |
| setId(other.getId()); |
| } |
| if (other.hasType()) { |
| setType(other.getType()); |
| } |
| if (messageBuilder_ == null) { |
| if (!other.message_.isEmpty()) { |
| if (message_.isEmpty()) { |
| message_ = other.message_; |
| bitField0_ = (bitField0_ & ~0x00000004); |
| } else { |
| ensureMessageIsMutable(); |
| message_.addAll(other.message_); |
| } |
| onChanged(); |
| } |
| } else { |
| if (!other.message_.isEmpty()) { |
| if (messageBuilder_.isEmpty()) { |
| messageBuilder_.dispose(); |
| messageBuilder_ = null; |
| message_ = other.message_; |
| bitField0_ = (bitField0_ & ~0x00000004); |
| messageBuilder_ = |
| com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ? |
| getMessageFieldBuilder() : null; |
| } else { |
| messageBuilder_.addAllMessages(other.message_); |
| } |
| } |
| } |
| this.mergeUnknownFields(other.getUnknownFields()); |
| return this; |
| } |
| public final boolean isInitialized() { |
| if (!hasId()) { |
| return false; |
| } |
| if (!hasType()) { |
| return false; |
| } |
| return true; |
| } |
| public Builder mergeFrom( |
| com.google.protobuf.CodedInputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| com.google.protobuf.UnknownFieldSet.Builder unknownFields = |
| com.google.protobuf.UnknownFieldSet.newBuilder( |
| this.getUnknownFields()); |
| while (true) { |
| int tag = input.readTag(); |
| switch (tag) { |
| case 0: |
| this.setUnknownFields(unknownFields.build()); |
| onChanged(); |
| return this; |
| default: { |
| if (!parseUnknownField(input, unknownFields, |
| extensionRegistry, tag)) { |
| this.setUnknownFields(unknownFields.build()); |
| onChanged(); |
| return this; |
| } |
| break; |
| } |
| case 8: { |
| bitField0_ |= 0x00000001; |
| id_ = input.readInt32(); |
| break; |
| } |
| case 16: { |
| bitField0_ |= 0x00000002; |
| type_ = input.readInt32(); |
| break; |
| } |
| case 26: { |
| ioio.debugger.NetworkIOIOProtocol.Message.Builder subBuilder = ioio.debugger.NetworkIOIOProtocol.Message.newBuilder(); |
| input.readMessage(subBuilder, extensionRegistry); |
| addMessage(subBuilder.buildPartial()); |
| break; |
| } |
| } |
| } |
| } |
| private int bitField0_; |
| // required int32 id = 1; |
| private int id_ ; |
| public boolean hasId() { |
| return ((bitField0_ & 0x00000001) == 0x00000001); |
| } |
| public int getId() { |
| return id_; |
| } |
| public Builder setId(int value) { |
| bitField0_ |= 0x00000001; |
| id_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearId() { |
| bitField0_ = (bitField0_ & ~0x00000001); |
| id_ = 0; |
| onChanged(); |
| return this; |
| } |
| // required int32 type = 2; |
| private int type_ ; |
| public boolean hasType() { |
| return ((bitField0_ & 0x00000002) == 0x00000002); |
| } |
| public int getType() { |
| return type_; |
| } |
| public Builder setType(int value) { |
| bitField0_ |= 0x00000002; |
| type_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearType() { |
| bitField0_ = (bitField0_ & ~0x00000002); |
| type_ = 0; |
| onChanged(); |
| return this; |
| } |
| // repeated .ioio.debugger.Message message = 3; |
| private java.util.List<ioio.debugger.NetworkIOIOProtocol.Message> message_ = |
| java.util.Collections.emptyList(); |
| private void ensureMessageIsMutable() { |
| if (!((bitField0_ & 0x00000004) == 0x00000004)) { |
| message_ = new java.util.ArrayList<ioio.debugger.NetworkIOIOProtocol.Message>(message_); |
| bitField0_ |= 0x00000004; |
| } |
| } |
| private com.google.protobuf.RepeatedFieldBuilder< |
| ioio.debugger.NetworkIOIOProtocol.Message, ioio.debugger.NetworkIOIOProtocol.Message.Builder, ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder> messageBuilder_; |
| public java.util.List<ioio.debugger.NetworkIOIOProtocol.Message> getMessageList() { |
| if (messageBuilder_ == null) { |
| return java.util.Collections.unmodifiableList(message_); |
| } else { |
| return messageBuilder_.getMessageList(); |
| } |
| } |
| public int getMessageCount() { |
| if (messageBuilder_ == null) { |
| return message_.size(); |
| } else { |
| return messageBuilder_.getCount(); |
| } |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message getMessage(int index) { |
| if (messageBuilder_ == null) { |
| return message_.get(index); |
| } else { |
| return messageBuilder_.getMessage(index); |
| } |
| } |
| public Builder setMessage( |
| int index, ioio.debugger.NetworkIOIOProtocol.Message value) { |
| if (messageBuilder_ == null) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| ensureMessageIsMutable(); |
| message_.set(index, value); |
| onChanged(); |
| } else { |
| messageBuilder_.setMessage(index, value); |
| } |
| return this; |
| } |
| public Builder setMessage( |
| int index, ioio.debugger.NetworkIOIOProtocol.Message.Builder builderForValue) { |
| if (messageBuilder_ == null) { |
| ensureMessageIsMutable(); |
| message_.set(index, builderForValue.build()); |
| onChanged(); |
| } else { |
| messageBuilder_.setMessage(index, builderForValue.build()); |
| } |
| return this; |
| } |
| public Builder addMessage(ioio.debugger.NetworkIOIOProtocol.Message value) { |
| if (messageBuilder_ == null) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| ensureMessageIsMutable(); |
| message_.add(value); |
| onChanged(); |
| } else { |
| messageBuilder_.addMessage(value); |
| } |
| return this; |
| } |
| public Builder addMessage( |
| int index, ioio.debugger.NetworkIOIOProtocol.Message value) { |
| if (messageBuilder_ == null) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| ensureMessageIsMutable(); |
| message_.add(index, value); |
| onChanged(); |
| } else { |
| messageBuilder_.addMessage(index, value); |
| } |
| return this; |
| } |
| public Builder addMessage( |
| ioio.debugger.NetworkIOIOProtocol.Message.Builder builderForValue) { |
| if (messageBuilder_ == null) { |
| ensureMessageIsMutable(); |
| message_.add(builderForValue.build()); |
| onChanged(); |
| } else { |
| messageBuilder_.addMessage(builderForValue.build()); |
| } |
| return this; |
| } |
| public Builder addMessage( |
| int index, ioio.debugger.NetworkIOIOProtocol.Message.Builder builderForValue) { |
| if (messageBuilder_ == null) { |
| ensureMessageIsMutable(); |
| message_.add(index, builderForValue.build()); |
| onChanged(); |
| } else { |
| messageBuilder_.addMessage(index, builderForValue.build()); |
| } |
| return this; |
| } |
| public Builder addAllMessage( |
| java.lang.Iterable<? extends ioio.debugger.NetworkIOIOProtocol.Message> values) { |
| if (messageBuilder_ == null) { |
| ensureMessageIsMutable(); |
| super.addAll(values, message_); |
| onChanged(); |
| } else { |
| messageBuilder_.addAllMessages(values); |
| } |
| return this; |
| } |
| public Builder clearMessage() { |
| if (messageBuilder_ == null) { |
| message_ = java.util.Collections.emptyList(); |
| bitField0_ = (bitField0_ & ~0x00000004); |
| onChanged(); |
| } else { |
| messageBuilder_.clear(); |
| } |
| return this; |
| } |
| public Builder removeMessage(int index) { |
| if (messageBuilder_ == null) { |
| ensureMessageIsMutable(); |
| message_.remove(index); |
| onChanged(); |
| } else { |
| messageBuilder_.remove(index); |
| } |
| return this; |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message.Builder getMessageBuilder( |
| int index) { |
| return getMessageFieldBuilder().getBuilder(index); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder getMessageOrBuilder( |
| int index) { |
| if (messageBuilder_ == null) { |
| return message_.get(index); } else { |
| return messageBuilder_.getMessageOrBuilder(index); |
| } |
| } |
| public java.util.List<? extends ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder> |
| getMessageOrBuilderList() { |
| if (messageBuilder_ != null) { |
| return messageBuilder_.getMessageOrBuilderList(); |
| } else { |
| return java.util.Collections.unmodifiableList(message_); |
| } |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message.Builder addMessageBuilder() { |
| return getMessageFieldBuilder().addBuilder( |
| ioio.debugger.NetworkIOIOProtocol.Message.getDefaultInstance()); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message.Builder addMessageBuilder( |
| int index) { |
| return getMessageFieldBuilder().addBuilder( |
| index, ioio.debugger.NetworkIOIOProtocol.Message.getDefaultInstance()); |
| } |
| public java.util.List<ioio.debugger.NetworkIOIOProtocol.Message.Builder> |
| getMessageBuilderList() { |
| return getMessageFieldBuilder().getBuilderList(); |
| } |
| private com.google.protobuf.RepeatedFieldBuilder< |
| ioio.debugger.NetworkIOIOProtocol.Message, ioio.debugger.NetworkIOIOProtocol.Message.Builder, ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder> |
| getMessageFieldBuilder() { |
| if (messageBuilder_ == null) { |
| messageBuilder_ = new com.google.protobuf.RepeatedFieldBuilder< |
| ioio.debugger.NetworkIOIOProtocol.Message, ioio.debugger.NetworkIOIOProtocol.Message.Builder, ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder>( |
| message_, |
| ((bitField0_ & 0x00000004) == 0x00000004), |
| getParentForChildren(), |
| isClean()); |
| message_ = null; |
| } |
| return messageBuilder_; |
| } |
| // @@protoc_insertion_point(builder_scope:ioio.debugger.TrackingMessage) |
| } |
| static { |
| defaultInstance = new TrackingMessage(true); |
| defaultInstance.initFields(); |
| } |
| // @@protoc_insertion_point(class_scope:ioio.debugger.TrackingMessage) |
| } |
| public interface MessageOrBuilder |
| extends com.google.protobuf.MessageOrBuilder { |
| // optional int32 pin = 1; |
| boolean hasPin(); |
| int getPin(); |
| // repeated double data = 2; |
| java.util.List<java.lang.Double> getDataList(); |
| int getDataCount(); |
| double getData(int index); |
| // optional string type = 3; |
| boolean hasType(); |
| String getType(); |
| // optional int64 freq = 4; |
| boolean hasFreq(); |
| long getFreq(); |
| // optional string mode = 5; |
| boolean hasMode(); |
| String getMode(); |
| // optional string state = 6; |
| boolean hasState(); |
| String getState(); |
| // optional bool boolean = 7; |
| boolean hasBoolean(); |
| boolean getBoolean(); |
| } |
| public static final class Message extends |
| com.google.protobuf.GeneratedMessage |
| implements MessageOrBuilder { |
| // Use Message.newBuilder() to construct. |
| private Message(Builder builder) { |
| super(builder); |
| } |
| private Message(boolean noInit) {} |
| private static final Message defaultInstance; |
| public static Message getDefaultInstance() { |
| return defaultInstance; |
| } |
| public Message getDefaultInstanceForType() { |
| return defaultInstance; |
| } |
| public static final com.google.protobuf.Descriptors.Descriptor |
| getDescriptor() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_Message_descriptor; |
| } |
| protected com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internalGetFieldAccessorTable() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_Message_fieldAccessorTable; |
| } |
| private int bitField0_; |
| // optional int32 pin = 1; |
| public static final int PIN_FIELD_NUMBER = 1; |
| private int pin_; |
| public boolean hasPin() { |
| return ((bitField0_ & 0x00000001) == 0x00000001); |
| } |
| public int getPin() { |
| return pin_; |
| } |
| // repeated double data = 2; |
| public static final int DATA_FIELD_NUMBER = 2; |
| private java.util.List<java.lang.Double> data_; |
| public java.util.List<java.lang.Double> |
| getDataList() { |
| return data_; |
| } |
| public int getDataCount() { |
| return data_.size(); |
| } |
| public double getData(int index) { |
| return data_.get(index); |
| } |
| // optional string type = 3; |
| public static final int TYPE_FIELD_NUMBER = 3; |
| private java.lang.Object type_; |
| public boolean hasType() { |
| return ((bitField0_ & 0x00000002) == 0x00000002); |
| } |
| public String getType() { |
| java.lang.Object ref = type_; |
| if (ref instanceof String) { |
| return (String) ref; |
| } else { |
| com.google.protobuf.ByteString bs = |
| (com.google.protobuf.ByteString) ref; |
| String s = bs.toStringUtf8(); |
| if (com.google.protobuf.Internal.isValidUtf8(bs)) { |
| type_ = s; |
| } |
| return s; |
| } |
| } |
| private com.google.protobuf.ByteString getTypeBytes() { |
| java.lang.Object ref = type_; |
| if (ref instanceof String) { |
| com.google.protobuf.ByteString b = |
| com.google.protobuf.ByteString.copyFromUtf8((String) ref); |
| type_ = b; |
| return b; |
| } else { |
| return (com.google.protobuf.ByteString) ref; |
| } |
| } |
| // optional int64 freq = 4; |
| public static final int FREQ_FIELD_NUMBER = 4; |
| private long freq_; |
| public boolean hasFreq() { |
| return ((bitField0_ & 0x00000004) == 0x00000004); |
| } |
| public long getFreq() { |
| return freq_; |
| } |
| // optional string mode = 5; |
| public static final int MODE_FIELD_NUMBER = 5; |
| private java.lang.Object mode_; |
| public boolean hasMode() { |
| return ((bitField0_ & 0x00000008) == 0x00000008); |
| } |
| public String getMode() { |
| java.lang.Object ref = mode_; |
| if (ref instanceof String) { |
| return (String) ref; |
| } else { |
| com.google.protobuf.ByteString bs = |
| (com.google.protobuf.ByteString) ref; |
| String s = bs.toStringUtf8(); |
| if (com.google.protobuf.Internal.isValidUtf8(bs)) { |
| mode_ = s; |
| } |
| return s; |
| } |
| } |
| private com.google.protobuf.ByteString getModeBytes() { |
| java.lang.Object ref = mode_; |
| if (ref instanceof String) { |
| com.google.protobuf.ByteString b = |
| com.google.protobuf.ByteString.copyFromUtf8((String) ref); |
| mode_ = b; |
| return b; |
| } else { |
| return (com.google.protobuf.ByteString) ref; |
| } |
| } |
| // optional string state = 6; |
| public static final int STATE_FIELD_NUMBER = 6; |
| private java.lang.Object state_; |
| public boolean hasState() { |
| return ((bitField0_ & 0x00000010) == 0x00000010); |
| } |
| public String getState() { |
| java.lang.Object ref = state_; |
| if (ref instanceof String) { |
| return (String) ref; |
| } else { |
| com.google.protobuf.ByteString bs = |
| (com.google.protobuf.ByteString) ref; |
| String s = bs.toStringUtf8(); |
| if (com.google.protobuf.Internal.isValidUtf8(bs)) { |
| state_ = s; |
| } |
| return s; |
| } |
| } |
| private com.google.protobuf.ByteString getStateBytes() { |
| java.lang.Object ref = state_; |
| if (ref instanceof String) { |
| com.google.protobuf.ByteString b = |
| com.google.protobuf.ByteString.copyFromUtf8((String) ref); |
| state_ = b; |
| return b; |
| } else { |
| return (com.google.protobuf.ByteString) ref; |
| } |
| } |
| // optional bool boolean = 7; |
| public static final int BOOLEAN_FIELD_NUMBER = 7; |
| private boolean boolean_; |
| public boolean hasBoolean() { |
| return ((bitField0_ & 0x00000020) == 0x00000020); |
| } |
| public boolean getBoolean() { |
| return boolean_; |
| } |
| private void initFields() { |
| pin_ = 0; |
| data_ = java.util.Collections.emptyList();; |
| type_ = ""; |
| freq_ = 0L; |
| mode_ = ""; |
| state_ = ""; |
| boolean_ = false; |
| } |
| private byte memoizedIsInitialized = -1; |
| public final boolean isInitialized() { |
| byte isInitialized = memoizedIsInitialized; |
| if (isInitialized != -1) return isInitialized == 1; |
| memoizedIsInitialized = 1; |
| return true; |
| } |
| public void writeTo(com.google.protobuf.CodedOutputStream output) |
| throws java.io.IOException { |
| getSerializedSize(); |
| if (((bitField0_ & 0x00000001) == 0x00000001)) { |
| output.writeInt32(1, pin_); |
| } |
| for (int i = 0; i < data_.size(); i++) { |
| output.writeDouble(2, data_.get(i)); |
| } |
| if (((bitField0_ & 0x00000002) == 0x00000002)) { |
| output.writeBytes(3, getTypeBytes()); |
| } |
| if (((bitField0_ & 0x00000004) == 0x00000004)) { |
| output.writeInt64(4, freq_); |
| } |
| if (((bitField0_ & 0x00000008) == 0x00000008)) { |
| output.writeBytes(5, getModeBytes()); |
| } |
| if (((bitField0_ & 0x00000010) == 0x00000010)) { |
| output.writeBytes(6, getStateBytes()); |
| } |
| if (((bitField0_ & 0x00000020) == 0x00000020)) { |
| output.writeBool(7, boolean_); |
| } |
| getUnknownFields().writeTo(output); |
| } |
| private int memoizedSerializedSize = -1; |
| public int getSerializedSize() { |
| int size = memoizedSerializedSize; |
| if (size != -1) return size; |
| size = 0; |
| if (((bitField0_ & 0x00000001) == 0x00000001)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeInt32Size(1, pin_); |
| } |
| { |
| int dataSize = 0; |
| dataSize = 8 * getDataList().size(); |
| size += dataSize; |
| size += 1 * getDataList().size(); |
| } |
| if (((bitField0_ & 0x00000002) == 0x00000002)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeBytesSize(3, getTypeBytes()); |
| } |
| if (((bitField0_ & 0x00000004) == 0x00000004)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeInt64Size(4, freq_); |
| } |
| if (((bitField0_ & 0x00000008) == 0x00000008)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeBytesSize(5, getModeBytes()); |
| } |
| if (((bitField0_ & 0x00000010) == 0x00000010)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeBytesSize(6, getStateBytes()); |
| } |
| if (((bitField0_ & 0x00000020) == 0x00000020)) { |
| size += com.google.protobuf.CodedOutputStream |
| .computeBoolSize(7, boolean_); |
| } |
| size += getUnknownFields().getSerializedSize(); |
| memoizedSerializedSize = size; |
| return size; |
| } |
| private static final long serialVersionUID = 0L; |
| @java.lang.Override |
| protected java.lang.Object writeReplace() |
| throws java.io.ObjectStreamException { |
| return super.writeReplace(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| com.google.protobuf.ByteString data) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| com.google.protobuf.ByteString data, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom(byte[] data) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| byte[] data, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| return newBuilder().mergeFrom(data, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom(java.io.InputStream input) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| java.io.InputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input, extensionRegistry) |
| .buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseDelimitedFrom(java.io.InputStream input) |
| throws java.io.IOException { |
| Builder builder = newBuilder(); |
| if (builder.mergeDelimitedFrom(input)) { |
| return builder.buildParsed(); |
| } else { |
| return null; |
| } |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseDelimitedFrom( |
| java.io.InputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| Builder builder = newBuilder(); |
| if (builder.mergeDelimitedFrom(input, extensionRegistry)) { |
| return builder.buildParsed(); |
| } else { |
| return null; |
| } |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| com.google.protobuf.CodedInputStream input) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input).buildParsed(); |
| } |
| public static ioio.debugger.NetworkIOIOProtocol.Message parseFrom( |
| com.google.protobuf.CodedInputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| return newBuilder().mergeFrom(input, extensionRegistry) |
| .buildParsed(); |
| } |
| public static Builder newBuilder() { return Builder.create(); } |
| public Builder newBuilderForType() { return newBuilder(); } |
| public static Builder newBuilder(ioio.debugger.NetworkIOIOProtocol.Message prototype) { |
| return newBuilder().mergeFrom(prototype); |
| } |
| public Builder toBuilder() { return newBuilder(this); } |
| @java.lang.Override |
| protected Builder newBuilderForType( |
| com.google.protobuf.GeneratedMessage.BuilderParent parent) { |
| Builder builder = new Builder(parent); |
| return builder; |
| } |
| public static final class Builder extends |
| com.google.protobuf.GeneratedMessage.Builder<Builder> |
| implements ioio.debugger.NetworkIOIOProtocol.MessageOrBuilder { |
| public static final com.google.protobuf.Descriptors.Descriptor |
| getDescriptor() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_Message_descriptor; |
| } |
| protected com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internalGetFieldAccessorTable() { |
| return ioio.debugger.NetworkIOIOProtocol.internal_static_ioio_debugger_Message_fieldAccessorTable; |
| } |
| // Construct using ioio.debugger.NetworkIOIOProtocol.Message.newBuilder() |
| private Builder() { |
| maybeForceBuilderInitialization(); |
| } |
| private Builder(BuilderParent parent) { |
| super(parent); |
| maybeForceBuilderInitialization(); |
| } |
| private void maybeForceBuilderInitialization() { |
| if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) { |
| } |
| } |
| private static Builder create() { |
| return new Builder(); |
| } |
| public Builder clear() { |
| super.clear(); |
| pin_ = 0; |
| bitField0_ = (bitField0_ & ~0x00000001); |
| data_ = java.util.Collections.emptyList();; |
| bitField0_ = (bitField0_ & ~0x00000002); |
| type_ = ""; |
| bitField0_ = (bitField0_ & ~0x00000004); |
| freq_ = 0L; |
| bitField0_ = (bitField0_ & ~0x00000008); |
| mode_ = ""; |
| bitField0_ = (bitField0_ & ~0x00000010); |
| state_ = ""; |
| bitField0_ = (bitField0_ & ~0x00000020); |
| boolean_ = false; |
| bitField0_ = (bitField0_ & ~0x00000040); |
| return this; |
| } |
| public Builder clone() { |
| return create().mergeFrom(buildPartial()); |
| } |
| public com.google.protobuf.Descriptors.Descriptor |
| getDescriptorForType() { |
| return ioio.debugger.NetworkIOIOProtocol.Message.getDescriptor(); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message getDefaultInstanceForType() { |
| return ioio.debugger.NetworkIOIOProtocol.Message.getDefaultInstance(); |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message build() { |
| ioio.debugger.NetworkIOIOProtocol.Message result = buildPartial(); |
| if (!result.isInitialized()) { |
| throw newUninitializedMessageException(result); |
| } |
| return result; |
| } |
| private ioio.debugger.NetworkIOIOProtocol.Message buildParsed() |
| throws com.google.protobuf.InvalidProtocolBufferException { |
| ioio.debugger.NetworkIOIOProtocol.Message result = buildPartial(); |
| if (!result.isInitialized()) { |
| throw newUninitializedMessageException( |
| result).asInvalidProtocolBufferException(); |
| } |
| return result; |
| } |
| public ioio.debugger.NetworkIOIOProtocol.Message buildPartial() { |
| ioio.debugger.NetworkIOIOProtocol.Message result = new ioio.debugger.NetworkIOIOProtocol.Message(this); |
| int from_bitField0_ = bitField0_; |
| int to_bitField0_ = 0; |
| if (((from_bitField0_ & 0x00000001) == 0x00000001)) { |
| to_bitField0_ |= 0x00000001; |
| } |
| result.pin_ = pin_; |
| if (((bitField0_ & 0x00000002) == 0x00000002)) { |
| data_ = java.util.Collections.unmodifiableList(data_); |
| bitField0_ = (bitField0_ & ~0x00000002); |
| } |
| result.data_ = data_; |
| if (((from_bitField0_ & 0x00000004) == 0x00000004)) { |
| to_bitField0_ |= 0x00000002; |
| } |
| result.type_ = type_; |
| if (((from_bitField0_ & 0x00000008) == 0x00000008)) { |
| to_bitField0_ |= 0x00000004; |
| } |
| result.freq_ = freq_; |
| if (((from_bitField0_ & 0x00000010) == 0x00000010)) { |
| to_bitField0_ |= 0x00000008; |
| } |
| result.mode_ = mode_; |
| if (((from_bitField0_ & 0x00000020) == 0x00000020)) { |
| to_bitField0_ |= 0x00000010; |
| } |
| result.state_ = state_; |
| if (((from_bitField0_ & 0x00000040) == 0x00000040)) { |
| to_bitField0_ |= 0x00000020; |
| } |
| result.boolean_ = boolean_; |
| result.bitField0_ = to_bitField0_; |
| onBuilt(); |
| return result; |
| } |
| public Builder mergeFrom(com.google.protobuf.Message other) { |
| if (other instanceof ioio.debugger.NetworkIOIOProtocol.Message) { |
| return mergeFrom((ioio.debugger.NetworkIOIOProtocol.Message)other); |
| } else { |
| super.mergeFrom(other); |
| return this; |
| } |
| } |
| public Builder mergeFrom(ioio.debugger.NetworkIOIOProtocol.Message other) { |
| if (other == ioio.debugger.NetworkIOIOProtocol.Message.getDefaultInstance()) return this; |
| if (other.hasPin()) { |
| setPin(other.getPin()); |
| } |
| if (!other.data_.isEmpty()) { |
| if (data_.isEmpty()) { |
| data_ = other.data_; |
| bitField0_ = (bitField0_ & ~0x00000002); |
| } else { |
| ensureDataIsMutable(); |
| data_.addAll(other.data_); |
| } |
| onChanged(); |
| } |
| if (other.hasType()) { |
| setType(other.getType()); |
| } |
| if (other.hasFreq()) { |
| setFreq(other.getFreq()); |
| } |
| if (other.hasMode()) { |
| setMode(other.getMode()); |
| } |
| if (other.hasState()) { |
| setState(other.getState()); |
| } |
| if (other.hasBoolean()) { |
| setBoolean(other.getBoolean()); |
| } |
| this.mergeUnknownFields(other.getUnknownFields()); |
| return this; |
| } |
| public final boolean isInitialized() { |
| return true; |
| } |
| public Builder mergeFrom( |
| com.google.protobuf.CodedInputStream input, |
| com.google.protobuf.ExtensionRegistryLite extensionRegistry) |
| throws java.io.IOException { |
| com.google.protobuf.UnknownFieldSet.Builder unknownFields = |
| com.google.protobuf.UnknownFieldSet.newBuilder( |
| this.getUnknownFields()); |
| while (true) { |
| int tag = input.readTag(); |
| switch (tag) { |
| case 0: |
| this.setUnknownFields(unknownFields.build()); |
| onChanged(); |
| return this; |
| default: { |
| if (!parseUnknownField(input, unknownFields, |
| extensionRegistry, tag)) { |
| this.setUnknownFields(unknownFields.build()); |
| onChanged(); |
| return this; |
| } |
| break; |
| } |
| case 8: { |
| bitField0_ |= 0x00000001; |
| pin_ = input.readInt32(); |
| break; |
| } |
| case 17: { |
| ensureDataIsMutable(); |
| data_.add(input.readDouble()); |
| break; |
| } |
| case 18: { |
| int length = input.readRawVarint32(); |
| int limit = input.pushLimit(length); |
| while (input.getBytesUntilLimit() > 0) { |
| addData(input.readDouble()); |
| } |
| input.popLimit(limit); |
| break; |
| } |
| case 26: { |
| bitField0_ |= 0x00000004; |
| type_ = input.readBytes(); |
| break; |
| } |
| case 32: { |
| bitField0_ |= 0x00000008; |
| freq_ = input.readInt64(); |
| break; |
| } |
| case 42: { |
| bitField0_ |= 0x00000010; |
| mode_ = input.readBytes(); |
| break; |
| } |
| case 50: { |
| bitField0_ |= 0x00000020; |
| state_ = input.readBytes(); |
| break; |
| } |
| case 56: { |
| bitField0_ |= 0x00000040; |
| boolean_ = input.readBool(); |
| break; |
| } |
| } |
| } |
| } |
| private int bitField0_; |
| // optional int32 pin = 1; |
| private int pin_ ; |
| public boolean hasPin() { |
| return ((bitField0_ & 0x00000001) == 0x00000001); |
| } |
| public int getPin() { |
| return pin_; |
| } |
| public Builder setPin(int value) { |
| bitField0_ |= 0x00000001; |
| pin_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearPin() { |
| bitField0_ = (bitField0_ & ~0x00000001); |
| pin_ = 0; |
| onChanged(); |
| return this; |
| } |
| // repeated double data = 2; |
| private java.util.List<java.lang.Double> data_ = java.util.Collections.emptyList();; |
| private void ensureDataIsMutable() { |
| if (!((bitField0_ & 0x00000002) == 0x00000002)) { |
| data_ = new java.util.ArrayList<java.lang.Double>(data_); |
| bitField0_ |= 0x00000002; |
| } |
| } |
| public java.util.List<java.lang.Double> |
| getDataList() { |
| return java.util.Collections.unmodifiableList(data_); |
| } |
| public int getDataCount() { |
| return data_.size(); |
| } |
| public double getData(int index) { |
| return data_.get(index); |
| } |
| public Builder setData( |
| int index, double value) { |
| ensureDataIsMutable(); |
| data_.set(index, value); |
| onChanged(); |
| return this; |
| } |
| public Builder addData(double value) { |
| ensureDataIsMutable(); |
| data_.add(value); |
| onChanged(); |
| return this; |
| } |
| public Builder addAllData( |
| java.lang.Iterable<? extends java.lang.Double> values) { |
| ensureDataIsMutable(); |
| super.addAll(values, data_); |
| onChanged(); |
| return this; |
| } |
| public Builder clearData() { |
| data_ = java.util.Collections.emptyList();; |
| bitField0_ = (bitField0_ & ~0x00000002); |
| onChanged(); |
| return this; |
| } |
| // optional string type = 3; |
| private java.lang.Object type_ = ""; |
| public boolean hasType() { |
| return ((bitField0_ & 0x00000004) == 0x00000004); |
| } |
| public String getType() { |
| java.lang.Object ref = type_; |
| if (!(ref instanceof String)) { |
| String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); |
| type_ = s; |
| return s; |
| } else { |
| return (String) ref; |
| } |
| } |
| public Builder setType(String value) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| bitField0_ |= 0x00000004; |
| type_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearType() { |
| bitField0_ = (bitField0_ & ~0x00000004); |
| type_ = getDefaultInstance().getType(); |
| onChanged(); |
| return this; |
| } |
| void setType(com.google.protobuf.ByteString value) { |
| bitField0_ |= 0x00000004; |
| type_ = value; |
| onChanged(); |
| } |
| // optional int64 freq = 4; |
| private long freq_ ; |
| public boolean hasFreq() { |
| return ((bitField0_ & 0x00000008) == 0x00000008); |
| } |
| public long getFreq() { |
| return freq_; |
| } |
| public Builder setFreq(long value) { |
| bitField0_ |= 0x00000008; |
| freq_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearFreq() { |
| bitField0_ = (bitField0_ & ~0x00000008); |
| freq_ = 0L; |
| onChanged(); |
| return this; |
| } |
| // optional string mode = 5; |
| private java.lang.Object mode_ = ""; |
| public boolean hasMode() { |
| return ((bitField0_ & 0x00000010) == 0x00000010); |
| } |
| public String getMode() { |
| java.lang.Object ref = mode_; |
| if (!(ref instanceof String)) { |
| String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); |
| mode_ = s; |
| return s; |
| } else { |
| return (String) ref; |
| } |
| } |
| public Builder setMode(String value) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| bitField0_ |= 0x00000010; |
| mode_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearMode() { |
| bitField0_ = (bitField0_ & ~0x00000010); |
| mode_ = getDefaultInstance().getMode(); |
| onChanged(); |
| return this; |
| } |
| void setMode(com.google.protobuf.ByteString value) { |
| bitField0_ |= 0x00000010; |
| mode_ = value; |
| onChanged(); |
| } |
| // optional string state = 6; |
| private java.lang.Object state_ = ""; |
| public boolean hasState() { |
| return ((bitField0_ & 0x00000020) == 0x00000020); |
| } |
| public String getState() { |
| java.lang.Object ref = state_; |
| if (!(ref instanceof String)) { |
| String s = ((com.google.protobuf.ByteString) ref).toStringUtf8(); |
| state_ = s; |
| return s; |
| } else { |
| return (String) ref; |
| } |
| } |
| public Builder setState(String value) { |
| if (value == null) { |
| throw new NullPointerException(); |
| } |
| bitField0_ |= 0x00000020; |
| state_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearState() { |
| bitField0_ = (bitField0_ & ~0x00000020); |
| state_ = getDefaultInstance().getState(); |
| onChanged(); |
| return this; |
| } |
| void setState(com.google.protobuf.ByteString value) { |
| bitField0_ |= 0x00000020; |
| state_ = value; |
| onChanged(); |
| } |
| // optional bool boolean = 7; |
| private boolean boolean_ ; |
| public boolean hasBoolean() { |
| return ((bitField0_ & 0x00000040) == 0x00000040); |
| } |
| public boolean getBoolean() { |
| return boolean_; |
| } |
| public Builder setBoolean(boolean value) { |
| bitField0_ |= 0x00000040; |
| boolean_ = value; |
| onChanged(); |
| return this; |
| } |
| public Builder clearBoolean() { |
| bitField0_ = (bitField0_ & ~0x00000040); |
| boolean_ = false; |
| onChanged(); |
| return this; |
| } |
| // @@protoc_insertion_point(builder_scope:ioio.debugger.Message) |
| } |
| static { |
| defaultInstance = new Message(true); |
| defaultInstance.initFields(); |
| } |
| // @@protoc_insertion_point(class_scope:ioio.debugger.Message) |
| } |
| private static com.google.protobuf.Descriptors.Descriptor |
| internal_static_ioio_debugger_TrackingMessage_descriptor; |
| private static |
| com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internal_static_ioio_debugger_TrackingMessage_fieldAccessorTable; |
| private static com.google.protobuf.Descriptors.Descriptor |
| internal_static_ioio_debugger_Message_descriptor; |
| private static |
| com.google.protobuf.GeneratedMessage.FieldAccessorTable |
| internal_static_ioio_debugger_Message_fieldAccessorTable; |
| public static com.google.protobuf.Descriptors.FileDescriptor |
| getDescriptor() { |
| return descriptor; |
| } |
| private static com.google.protobuf.Descriptors.FileDescriptor |
| descriptor; |
| static { |
| java.lang.String[] descriptorData = { |
| "\n\031NetworkIOIOProtocol.proto\022\rioio.debugg" + |
| "er\"T\n\017TrackingMessage\022\n\n\002id\030\001 \002(\005\022\014\n\004typ" + |
| "e\030\002 \002(\005\022\'\n\007message\030\003 \003(\0132\026.ioio.debugger" + |
| ".Message\"n\n\007Message\022\013\n\003pin\030\001 \001(\005\022\014\n\004data" + |
| "\030\002 \003(\001\022\014\n\004type\030\003 \001(\t\022\014\n\004freq\030\004 \001(\003\022\014\n\004mo" + |
| "de\030\005 \001(\t\022\r\n\005state\030\006 \001(\t\022\017\n\007boolean\030\007 \001(\010" |
| }; |
| com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = |
| new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { |
| public com.google.protobuf.ExtensionRegistry assignDescriptors( |
| com.google.protobuf.Descriptors.FileDescriptor root) { |
| descriptor = root; |
| internal_static_ioio_debugger_TrackingMessage_descriptor = |
| getDescriptor().getMessageTypes().get(0); |
| internal_static_ioio_debugger_TrackingMessage_fieldAccessorTable = new |
| com.google.protobuf.GeneratedMessage.FieldAccessorTable( |
| internal_static_ioio_debugger_TrackingMessage_descriptor, |
| new java.lang.String[] { "Id", "Type", "Message", }, |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage.class, |
| ioio.debugger.NetworkIOIOProtocol.TrackingMessage.Builder.class); |
| internal_static_ioio_debugger_Message_descriptor = |
| getDescriptor().getMessageTypes().get(1); |
| internal_static_ioio_debugger_Message_fieldAccessorTable = new |
| com.google.protobuf.GeneratedMessage.FieldAccessorTable( |
| internal_static_ioio_debugger_Message_descriptor, |
| new java.lang.String[] { "Pin", "Data", "Type", "Freq", "Mode", "State", "Boolean", }, |
| ioio.debugger.NetworkIOIOProtocol.Message.class, |
| ioio.debugger.NetworkIOIOProtocol.Message.Builder.class); |
| return null; |
| } |
| }; |
| com.google.protobuf.Descriptors.FileDescriptor |
| .internalBuildGeneratedFileFrom(descriptorData, |
| new com.google.protobuf.Descriptors.FileDescriptor[] { |
| }, assigner); |
| } |
| // @@protoc_insertion_point(outer_class_scope) |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkIOIOProtocol.proto |
|---|
| 0,0 → 1,17 |
| package ioio.debugger; |
| message TrackingMessage { |
| required int32 id = 1; |
| required int32 type = 2; |
| repeated Message message = 3; |
| } |
| message Message { |
| optional int32 pin = 1; |
| repeated double data = 2; |
| optional string type = 3; |
| optional int64 freq = 4; |
| optional string mode = 5; |
| optional string state = 6; |
| optional bool boolean = 7; |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/NetworkMessageHandler.java |
|---|
| 0,0 → 1,29 |
| /************************************************************************** |
| * Copyright 2011 Jules White |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| ***************************************************************************/ |
| package ioio.debugger; |
| import org.jboss.netty.channel.Channel; |
| public interface NetworkMessageHandler<T> { |
| public void received(T msg); |
| public void channelException(Throwable e); |
| public void channelClosed(Channel c); |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/PinDetailActivity.java |
|---|
| 0,0 → 1,132 |
| package ioio.debugger; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import android.app.Activity; |
| import android.os.Bundle; |
| import android.view.Gravity; |
| import android.widget.TableLayout; |
| import android.widget.TableRow; |
| import android.widget.TableRow.LayoutParams; |
| import android.widget.TextView; |
| public class PinDetailActivity extends Activity { |
| private TableLayout root; |
| private int totalPins = 48; |
| private HashSet<Integer> AD; |
| private HashSet<Integer> PPSi; |
| private HashSet<Integer> PPSo; |
| private HashSet<Integer> FiveV; |
| private HashMap<Integer, String> I2C = new HashMap<Integer, String>(); |
| private HashMap<Integer, String> Comp = new HashMap<Integer, String>();; |
| @Override |
| public void onCreate(Bundle savedInstanceState) { |
| super.onCreate(savedInstanceState); |
| setContentView(R.layout.pin_details); |
| root = (TableLayout) findViewById(R.id.pin_table_root); |
| Integer[] ad = {31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46}; |
| AD = new HashSet<Integer>(Arrays.asList(ad)); |
| Integer[] ppsi = {3,4,5,6,7,9,10,11,12,13,14,27,28,29,30,31,32,34,35,36,37,38,39,40,45,46,47,48}; |
| PPSi = new HashSet<Integer>(Arrays.asList(ppsi)); |
| Integer[] ppso = {3,4,5,6,7,10,11,12,13,14,27,28,29,30,31,32,34,35,36,37,38,39,40,45,46,47,48}; |
| PPSo = new HashSet<Integer>(Arrays.asList(ppso)); |
| Integer[] fiveV = {3,4,5,6,7,10,11,12,13,14,18,19,20,21,22,23,24,25,26,47,48}; |
| FiveV = new HashSet<Integer>(Arrays.asList(fiveV)); |
| I2C.put(4, "DA0"); |
| I2C.put(5, "CL0"); |
| I2C.put(25, "DA2"); |
| I2C.put(26, "CL2"); |
| I2C.put(47, "DA1"); |
| I2C.put(48, "CL1"); |
| Comp.put(8, "3D"); |
| Comp.put(9, "3C"); |
| Comp.put(15, "3B"); |
| Comp.put(16, "3A"); |
| Comp.put(27, "1D"); |
| Comp.put(28, "1C"); |
| Comp.put(29, "2D"); |
| Comp.put(30, "2C"); |
| Comp.put(31, "1A"); |
| Comp.put(32, "1B"); |
| Comp.put(33, "2A"); |
| Comp.put(34, "2B"); |
| root.setStretchAllColumns(true); |
| for (Integer i = 1; i <= totalPins; i++) { |
| TableRow row = new TableRow(this); |
| TextView tv = new TextView(this); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| tv.setGravity(Gravity.CENTER); |
| tv.setText(String.valueOf(i)); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (AD.contains(i)) |
| tv.setText("\u2713"); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (I2C.containsKey(i)) |
| tv.setText(I2C.get(i)); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (PPSi.contains(i)) |
| tv.setText("\u2713"); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (PPSo.contains(i)) |
| tv.setText("\u2713"); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (FiveV.contains(i)) |
| tv.setText("\u2713"); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| tv = new TextView(this); |
| tv.setGravity(Gravity.CENTER); |
| tv.setLayoutParams(new LayoutParams(0, LayoutParams.WRAP_CONTENT, 1)); |
| if (Comp.containsKey(i)) |
| tv.setText(Comp.get(i)); |
| else |
| tv.setText(""); |
| row.addView(tv); |
| root.addView(row); |
| } |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/ViewWidget.java |
|---|
| 0,0 → 1,18 |
| package ioio.debugger; |
| import android.view.View; |
| public interface ViewWidget { |
| public void stopThread(); |
| public void startThread(); |
| public void clearData(); |
| public void setStopSignal(); |
| public void resetStopSignal(); |
| public void sendDataHistory(); |
| public View getView(); |
| public Thread getThread(); |
| public void setPin(int pin); |
| public int getPin(); |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/ViewWidgetGraphText.java |
|---|
| 0,0 → 1,194 |
| package ioio.debugger; |
| import java.util.LinkedList; |
| import com.androidplot.Plot.BorderStyle; |
| import com.androidplot.xy.BoundaryMode; |
| import com.androidplot.xy.LineAndPointFormatter; |
| import com.androidplot.xy.StepFormatter; |
| import com.androidplot.xy.XYPlot; |
| import com.androidplot.xy.XYStepMode; |
| import android.graphics.Color; |
| import android.os.Handler; |
| import android.view.View; |
| import android.widget.TextView; |
| public class ViewWidgetGraphText implements ViewWidget { |
| private View view; |
| private Runnable run; |
| private Thread thread; |
| private Handler handler = new Handler(); |
| private GenericXYSeries plotData; |
| private XYPlot historyPlot; |
| private int pin; |
| public ViewWidgetGraphText() { |
| } |
| @Override |
| public void stopThread() { |
| thread.interrupt(); |
| } |
| @Override |
| public void startThread() { |
| // Kill the thread if it is already running |
| if (thread != null && thread.isAlive()) |
| thread.interrupt(); |
| // Start a new thread and run the passed Runnable |
| thread = new Thread (run); |
| thread.start(); |
| } |
| @Override |
| public View getView() { |
| return view; |
| } |
| @Override |
| public Thread getThread() { |
| return thread; |
| } |
| @Override |
| public void clearData() { |
| plotData.clearData(); |
| } |
| @Override |
| public void setStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_graphText_status); |
| tv.setTextColor(Color.RED); |
| } |
| }); |
| } |
| @Override |
| public void resetStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_graphText_status); |
| tv.setTextColor(Color.WHITE); |
| } |
| }); |
| } |
| @Override |
| public void sendDataHistory() { |
| LinkedList<Number> data = plotData.getData(); |
| Double[] data2 = data.toArray(new Double[data.size()]); |
| IOIODebuggerActivity.get_networkMgr().sendData(pin, data2); |
| } |
| @Override |
| public int getPin() { |
| return pin; |
| } |
| public void setPin(final int p) { |
| pin = p; |
| } |
| public void updateText(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_graphText_text); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void updateStatus(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_graphText_status); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void setView(View view, boolean useStep, int historyLength) { |
| this.view = view; |
| // Set graph plot details |
| plotData = new GenericXYSeries("Analog In", historyLength); |
| historyPlot = (XYPlot) view.findViewById(R.id.layout_graphText_graph); |
| // Add data to plot |
| if (!useStep) |
| historyPlot.addSeries(plotData, new LineAndPointFormatter(Color.rgb(0, 0, 200), Color.rgb(0, 0, 100),Color.rgb(150, 150, 190))); |
| else { |
| StepFormatter stepFormatter = new StepFormatter(Color.rgb(0, 0, 0), Color.rgb(150, 190, 150)); |
| stepFormatter.getLinePaint().setStrokeWidth(1); |
| historyPlot.addSeries(plotData, stepFormatter); |
| } |
| // Set boundary and ticks |
| historyPlot.setRangeBoundaries(0, 3.3, BoundaryMode.FIXED); |
| historyPlot.setDomainBoundaries(0, historyLength, BoundaryMode.FIXED); |
| historyPlot.setDomainStepValue(5); |
| historyPlot.setRangeStep(XYStepMode.SUBDIVIDE, 4); |
| historyPlot.setTicksPerRangeLabel(3); |
| // Remove labels and legend |
| historyPlot.getLegendWidget().setVisible(false); |
| historyPlot.getDomainLabelWidget().setVisible(false); |
| historyPlot.getRangeLabelWidget().setVisible(false); |
| historyPlot.getTitleWidget().setVisible(false); |
| // Remove extra margin space |
| historyPlot.getGraphWidget().setMargins(0, 10, 10, 0); |
| historyPlot.getGraphWidget().setRangeLabelWidth(30); |
| historyPlot.getGraphWidget().setDomainLabelWidth(15); |
| historyPlot.getGraphWidget().setMarginLeft(-5); |
| historyPlot.getGraphWidget().setMarginRight(25); |
| historyPlot.setPlotMargins(0, 0, 0, 0); |
| historyPlot.setPlotPadding(0, 0, 0, 0); |
| // Remove background color |
| historyPlot.getGraphWidget().setBackgroundPaint(null); |
| historyPlot.setBackgroundPaint(null); |
| historyPlot.setBorderPaint(null); |
| historyPlot.setBorderStyle(BorderStyle.SQUARE, null, null); |
| historyPlot.disableAllMarkup(); |
| } |
| public void setRunnable(Runnable r) { |
| run = r; |
| } |
| public void updateData(Number num) { |
| plotData.addDataToList(num); |
| } |
| public void refreshGraph() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| historyPlot.redraw(); |
| } |
| }); |
| } |
| public void setRange(Number start, Number end) { |
| historyPlot.setRangeBoundaries(start, end, BoundaryMode.FIXED); |
| } |
| public void setDomain(Number length) { |
| historyPlot.setDomainBoundaries(0, length, BoundaryMode.FIXED); |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/ViewWidgetSimpleText.java |
|---|
| 0,0 → 1,117 |
| package ioio.debugger; |
| import android.graphics.Color; |
| import android.os.Handler; |
| import android.view.View; |
| import android.widget.TextView; |
| public class ViewWidgetSimpleText implements ViewWidget { |
| private View view; |
| private Runnable run; |
| private Thread thread; |
| private Handler handler = new Handler(); |
| private int pin; |
| public ViewWidgetSimpleText() { |
| } |
| @Override |
| public void stopThread() { |
| thread.interrupt(); |
| } |
| @Override |
| public void startThread() { |
| // Kill the thread if it is already running |
| if (thread != null && thread.isAlive()) |
| thread.interrupt(); |
| // Start a new thread and run the passed Runnable |
| thread = new Thread (run); |
| thread.start(); |
| } |
| @Override |
| public View getView() { |
| return view; |
| } |
| @Override |
| public Thread getThread() { |
| return thread; |
| } |
| @Override |
| public void clearData() { |
| } |
| @Override |
| public void setStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_simpleText_status); |
| tv.setTextColor(Color.RED); |
| } |
| }); |
| } |
| @Override |
| public void resetStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_simpleText_status); |
| tv.setTextColor(Color.WHITE); |
| } |
| }); |
| } |
| @Override |
| public void sendDataHistory() { |
| } |
| @Override |
| public int getPin() { |
| return pin; |
| } |
| public void setPin(int pin) { |
| this.pin = pin; |
| } |
| public void updateText(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_simpleText_text); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void updateStatus(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_simpleText_status); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void setView(View view) { |
| this.view = view; |
| } |
| public void setRunnable(Runnable r) { |
| this.run = r; |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/ViewWidgetToggleText.java |
|---|
| 0,0 → 1,127 |
| package ioio.debugger; |
| import android.graphics.Color; |
| import android.os.Handler; |
| import android.view.View; |
| import android.widget.TextView; |
| public class ViewWidgetToggleText implements ViewWidget { |
| private View view; |
| private Runnable run; |
| private Thread thread; |
| private Handler handler = new Handler(); |
| private int pin; |
| private boolean toggle; |
| public ViewWidgetToggleText() { |
| } |
| @Override |
| public void stopThread() { |
| thread.interrupt(); |
| } |
| @Override |
| public void startThread() { |
| // Kill the thread if it is already running |
| if (thread != null && thread.isAlive()) |
| thread.interrupt(); |
| // Start a new thread and run the passed Runnable |
| thread = new Thread (run); |
| thread.start(); |
| } |
| @Override |
| public View getView() { |
| return view; |
| } |
| @Override |
| public Thread getThread() { |
| return thread; |
| } |
| @Override |
| public void clearData() { |
| } |
| @Override |
| public void setStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_toggleText_status); |
| tv.setTextColor(Color.RED); |
| } |
| }); |
| } |
| @Override |
| public void resetStopSignal() { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_toggleText_status); |
| tv.setTextColor(Color.WHITE); |
| } |
| }); |
| } |
| @Override |
| public void sendDataHistory() { |
| Double[] data = new Double[1]; |
| if (toggle) |
| data[0] = 3.3; |
| else |
| data[0] = 0.0; |
| IOIODebuggerActivity.get_networkMgr().sendData(pin, data); |
| } |
| @Override |
| public int getPin() { |
| return pin; |
| } |
| public void setPin(int pin) { |
| this.pin = pin; |
| } |
| public void updateText(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_toggleText_text); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void updateStatus(final String str) { |
| handler.post(new Runnable() { |
| @Override |
| public void run() { |
| TextView tv = (TextView)view.findViewById(R.id.layout_toggleText_status); |
| tv.setText(str); |
| } |
| }); |
| } |
| public void setToggle(boolean b) { |
| toggle = b; |
| } |
| public void setView(View view) { |
| this.view = view; |
| } |
| public void setRunnable(Runnable r) { |
| this.run = r; |
| } |
| } |
| /Android Development/IOIODebugger/src/ioio/debugger/build_protocol.sh |
|---|
| 0,0 → 1,0 |
| protoc NetworkIOIOProtocol.proto --java_out=../../ |