row : mCells) {\n for (MatrixCell cell : row ) {\n cell.setSquare(value);\n }\n }\n }\n\n public int getCols() {\n return mCols;\n }\n\n public void setCols(int value) {\n setSize(value, getRows());\n }\n\n public int getRows() {\n return mRows;\n }\n\n public void setRows(int value) {\n setSize(getCols(), value);\n }\n\n // internal classes\n\n // keeps track of a single pointer on the matrix\n private class MatrixPointer {\n\n private int mPointedId;\n private float mX, mY;\n private MatrixCell mPressedCell;\n\n private MatrixPointer(int pointerId, float x, float y, MatrixCell pressedCell) {\n mPointedId = pointerId;\n mX = x;\n mY = y;\n mPressedCell = pressedCell;\n }\n private void move(float x, float y) {\n mX = x;\n mY = y;\n }\n private MatrixCell getPressedCell() {\n return mPressedCell;\n }\n private float getX() {\n return mX;\n }\n private float getY() {\n return mY;\n }\n }\n\n // represents a cell on the matrix, used to keep track of the state\n public class MatrixCell {\n\n private int mRow, mCol, mCurrentColor, mReleasedColor, mPressedColor, mMovedColor;\n private RectF mBounds;\n private boolean mBorder, mPressed, mVisible, mSquare;\n\n private MatrixCell(int col, int row, RectF bounds, boolean visible, boolean border, int color, boolean square) {\n mCol = col;\n mRow = row;\n mBounds = bounds;\n mBorder = border;\n mPressed = false;\n mVisible = visible;\n mSquare = square;\n updateColors(color);\n }\n /*public int getRow() { return mRow; }\n public int getCol() { return mCol; }*/\n public RectF getBounds() {\n return mBounds;\n }\n private void setBounds(RectF value) {\n mBounds = value;\n }\n public RectF getInnerBounds() {\n float border = (mCellSize * Constants.BORDER_THICKNESS) / 2;\n return new RectF(\n mBounds.left + border,\n mBounds.top + border,\n mBounds.right - border,\n mBounds.bottom - border);\n }\n public int getColor() {\n return mCurrentColor;\n }\n public int getMovedColor() {\n return mMovedColor;\n }\n public void setColor(int value) {\n updateColors(value);\n }\n public boolean getBorder() {\n return mBorder;\n }\n public void setBorder(boolean value) {\n mBorder = value;\n }\n public boolean getVisible() {\n return mVisible;\n }\n public void setVisible(boolean value) {\n mVisible = value;\n }\n public boolean getSquare() {\n return mSquare;\n }\n public void setSquare(boolean value) {\n mSquare = value;\n }\n public int getCol() {\n return mCol;\n }\n public int getRow() {\n return mRow;\n }\n public float getWidth() {\n return mBounds.right - mBounds.left;\n }\n public float getHeight() {\n return mBounds.bottom - mBounds.top;\n }\n public boolean getPressed() {\n return mPressed;\n }\n\n // called when the cell is pressed\n private void press() {\n mCurrentColor = mPressedColor;\n mPressed = true;\n invalidate();\n requestLayout();\n }\n\n // called when the cell is released\n private void release() {\n mCurrentColor = mReleasedColor;\n mPressed = false;\n invalidate();\n requestLayout();\n }\n\n // called when the cell is moved\n private void moved() {\n invalidate();\n requestLayout();\n }\n\n // manages the colors in the cell\n private void updateColors(int color) {\n mReleasedColor = color;\n mPressedColor = manipulateColor(color, 0.85f);\n mMovedColor = manipulateColor(color, 0.7f);\n\n if (mPressed) {\n mCurrentColor = mPressedColor;\n } else {\n mCurrentColor = mReleasedColor;\n }\n }\n\n // manipulates a color\n private int manipulateColor(int color, float factor) {\n int a = Color.alpha(color);\n int r = Math.round(Color.red(color) * factor);\n int g = Math.round(Color.green(color) * factor);\n int b = Math.round(Color.blue(color) * factor);\n return Color.argb(a,\n Math.min(r,255),\n Math.min(g,255),\n Math.min(b,255));\n }\n }\n}\n\n"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/bluedot/SettingsActivity.java",
"content": "package com.stuffaboutcode.bluedot;\n\nimport android.os.Bundle;\n\nimport androidx.appcompat.app.ActionBar;\nimport androidx.appcompat.app.AppCompatActivity;\nimport androidx.preference.PreferenceFragmentCompat;\nimport androidx.preference.Preference;\nimport androidx.preference.ListPreference;\nimport androidx.preference.SwitchPreferenceCompat;\nimport android.content.SharedPreferences;\n\npublic class SettingsActivity extends AppCompatActivity {\n\n @Override\n protected void onCreate(Bundle savedInstanceState) {\n super.onCreate(savedInstanceState);\n setContentView(R.layout.settings_activity);\n\n getSupportFragmentManager()\n .beginTransaction()\n .replace(R.id.settings, new SettingsFragment())\n .commit();\n\n ActionBar actionBar = getSupportActionBar();\n\n if (actionBar != null) {\n actionBar.setDisplayHomeAsUpEnabled(true);\n }\n\n }\n\n public static class SettingsFragment\n extends PreferenceFragmentCompat\n implements SharedPreferences.OnSharedPreferenceChangeListener{\n\n @Override\n public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {\n setPreferencesFromResource(R.xml.root_preferences, rootKey);\n\n setupPreferences();\n }\n\n @Override\n public void onResume() {\n super.onResume();\n\n getPreferenceScreen().getSharedPreferences()\n .registerOnSharedPreferenceChangeListener(this);\n }\n\n @Override\n public void onPause() {\n super.onPause();\n\n getPreferenceScreen().getSharedPreferences()\n .unregisterOnSharedPreferenceChangeListener(this);\n }\n\n @Override\n public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,String key) {\n setupPreferences();\n }\n\n private void setupPreferences() {\n Preference default_port = findPreference(\"default_port\");\n SwitchPreferenceCompat default_port_switch = (SwitchPreferenceCompat)default_port;\n Preference port = findPreference(\"port\");\n ListPreference port_list = (ListPreference) port;\n if (default_port_switch != null) {\n if (port_list != null) {\n // disable the port if the default_port is enabled\n if (default_port_switch.isChecked()) port.setVisible(false);\n else port.setVisible(true);\n // set the port summary\n port.setSummary(port_list.getEntry());\n }\n }\n }\n\n }\n}"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/Log.java",
"content": "/*\r\n * Copyright (C) 2013 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\npackage com.stuffaboutcode.logger;\r\n\r\n/**\r\n * Helper class for a list (or tree) of LoggerNodes.\r\n *\r\n * When this is set as the head of the list,\r\n * an instance of it can function as a drop-in replacement for {@link android.util.Log}.\r\n * Most of the methods in this class server only to map a method call in Log to its equivalent\r\n * in LogNode.
\r\n */\r\npublic class Log {\r\n // Grabbing the native values from Android's native logging facilities,\r\n // to make for easy migration and interop.\r\n public static final int NONE = -1;\r\n public static final int VERBOSE = android.util.Log.VERBOSE;\r\n public static final int DEBUG = android.util.Log.DEBUG;\r\n public static final int INFO = android.util.Log.INFO;\r\n public static final int WARN = android.util.Log.WARN;\r\n public static final int ERROR = android.util.Log.ERROR;\r\n public static final int ASSERT = android.util.Log.ASSERT;\r\n\r\n // Stores the beginning of the LogNode topology.\r\n private static LogNode mLogNode;\r\n\r\n /**\r\n * Returns the next LogNode in the linked list.\r\n */\r\n public static LogNode getLogNode() {\r\n return mLogNode;\r\n }\r\n\r\n /**\r\n * Sets the LogNode data will be sent to.\r\n */\r\n public static void setLogNode(LogNode node) {\r\n mLogNode = node;\r\n }\r\n\r\n /**\r\n * Instructs the LogNode to print the log data provided. Other LogNodes can\r\n * be chained to the end of the LogNode as desired.\r\n *\r\n * @param priority Log level of the data being logged. Verbose, Error, etc.\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void println(int priority, String tag, String msg, Throwable tr) {\r\n if (mLogNode != null) {\r\n mLogNode.println(priority, tag, msg, tr);\r\n }\r\n }\r\n\r\n /**\r\n * Instructs the LogNode to print the log data provided. Other LogNodes can\r\n * be chained to the end of the LogNode as desired.\r\n *\r\n * @param priority Log level of the data being logged. Verbose, Error, etc.\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged. The actual message to be logged.\r\n */\r\n public static void println(int priority, String tag, String msg) {\r\n println(priority, tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at VERBOSE priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void v(String tag, String msg, Throwable tr) {\r\n println(VERBOSE, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at VERBOSE priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void v(String tag, String msg) {\r\n v(tag, msg, null);\r\n }\r\n\r\n\r\n /**\r\n * Prints a message at DEBUG priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void d(String tag, String msg, Throwable tr) {\r\n println(DEBUG, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at DEBUG priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void d(String tag, String msg) {\r\n d(tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at INFO priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void i(String tag, String msg, Throwable tr) {\r\n println(INFO, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at INFO priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void i(String tag, String msg) {\r\n i(tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at WARN priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void w(String tag, String msg, Throwable tr) {\r\n println(WARN, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at WARN priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void w(String tag, String msg) {\r\n w(tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at WARN priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void w(String tag, Throwable tr) {\r\n w(tag, null, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at ERROR priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void e(String tag, String msg, Throwable tr) {\r\n println(ERROR, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at ERROR priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void e(String tag, String msg) {\r\n e(tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at ASSERT priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void wtf(String tag, String msg, Throwable tr) {\r\n println(ASSERT, tag, msg, tr);\r\n }\r\n\r\n /**\r\n * Prints a message at ASSERT priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged.\r\n */\r\n public static void wtf(String tag, String msg) {\r\n wtf(tag, msg, null);\r\n }\r\n\r\n /**\r\n * Prints a message at ASSERT priority.\r\n *\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public static void wtf(String tag, Throwable tr) {\r\n wtf(tag, null, tr);\r\n }\r\n}\r\n"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/LogFragment.java",
"content": "/*\r\n* Copyright 2013 The Android Open Source Project\r\n*\r\n* Licensed under the Apache License, Version 2.0 (the \"License\");\r\n* you may not use this file except in compliance with the License.\r\n* You may obtain a copy of the License at\r\n*\r\n* http://www.apache.org/licenses/LICENSE-2.0\r\n*\r\n* Unless required by applicable law or agreed to in writing, software\r\n* distributed under the License is distributed on an \"AS IS\" BASIS,\r\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n* See the License for the specific language governing permissions and\r\n* limitations under the License.\r\n*/\r\n/*\r\n * Copyright 2013 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n\r\npackage com.stuffaboutcode.logger;\r\n\r\nimport android.graphics.Typeface;\r\nimport android.os.Bundle;\r\nimport androidx.fragment.app.Fragment;\r\nimport android.text.Editable;\r\nimport android.text.TextWatcher;\r\nimport android.view.Gravity;\r\nimport android.view.LayoutInflater;\r\nimport android.view.View;\r\nimport android.view.ViewGroup;\r\nimport android.widget.ScrollView;\r\n\r\n/**\r\n * Simple fraggment which contains a LogView and uses is to output log data it receives\r\n * through the LogNode interface.\r\n */\r\npublic class LogFragment extends Fragment {\r\n\r\n private LogView mLogView;\r\n private ScrollView mScrollView;\r\n\r\n public LogFragment() {}\r\n\r\n public View inflateViews() {\r\n mScrollView = new ScrollView(getActivity());\r\n ViewGroup.LayoutParams scrollParams = new ViewGroup.LayoutParams(\r\n ViewGroup.LayoutParams.MATCH_PARENT,\r\n ViewGroup.LayoutParams.MATCH_PARENT);\r\n mScrollView.setLayoutParams(scrollParams);\r\n\r\n mLogView = new LogView(getActivity());\r\n ViewGroup.LayoutParams logParams = new ViewGroup.LayoutParams(scrollParams);\r\n logParams.height = ViewGroup.LayoutParams.WRAP_CONTENT;\r\n mLogView.setLayoutParams(logParams);\r\n mLogView.setClickable(true);\r\n mLogView.setFocusable(true);\r\n mLogView.setTypeface(Typeface.MONOSPACE);\r\n\r\n // Want to set padding as 16 dips, setPadding takes pixels. Hooray math!\r\n int paddingDips = 16;\r\n double scale = getResources().getDisplayMetrics().density;\r\n int paddingPixels = (int) ((paddingDips * (scale)) + .5);\r\n mLogView.setPadding(paddingPixels, paddingPixels, paddingPixels, paddingPixels);\r\n mLogView.setCompoundDrawablePadding(paddingPixels);\r\n\r\n mLogView.setGravity(Gravity.BOTTOM);\r\n mLogView.setTextAppearance(getActivity(), android.R.style.TextAppearance_Holo_Medium);\r\n\r\n mScrollView.addView(mLogView);\r\n return mScrollView;\r\n }\r\n\r\n @Override\r\n public View onCreateView(LayoutInflater inflater, ViewGroup container,\r\n Bundle savedInstanceState) {\r\n\r\n View result = inflateViews();\r\n\r\n mLogView.addTextChangedListener(new TextWatcher() {\r\n @Override\r\n public void beforeTextChanged(CharSequence s, int start, int count, int after) {}\r\n\r\n @Override\r\n public void onTextChanged(CharSequence s, int start, int before, int count) {}\r\n\r\n @Override\r\n public void afterTextChanged(Editable s) {\r\n mScrollView.fullScroll(ScrollView.FOCUS_DOWN);\r\n }\r\n });\r\n return result;\r\n }\r\n\r\n public LogView getLogView() {\r\n return mLogView;\r\n }\r\n}"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/LogNode.java",
"content": "/*\r\n * Copyright (C) 2012 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\npackage com.stuffaboutcode.logger;\r\n\r\n/**\r\n * Basic interface for a logging system that can output to one or more targets.\r\n * Note that in addition to classes that will output these logs in some format,\r\n * one can also implement this interface over a filter and insert that in the chain,\r\n * such that no targets further down see certain data, or see manipulated forms of the data.\r\n * You could, for instance, write a \"ToHtmlLoggerNode\" that just converted all the log data\r\n * it received to HTML and sent it along to the next node in the chain, without printing it\r\n * anywhere.\r\n */\r\npublic interface LogNode {\r\n\r\n /**\r\n * Instructs first LogNode in the list to print the log data provided.\r\n * @param priority Log level of the data being logged. Verbose, Error, etc.\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged. The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n public void println(int priority, String tag, String msg, Throwable tr);\r\n\r\n}\r\n"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/LogView.java",
"content": "/*\r\n * Copyright (C) 2013 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\npackage com.stuffaboutcode.logger;\r\n\r\nimport android.app.Activity;\r\nimport android.content.Context;\r\nimport android.util.*;\r\nimport android.widget.TextView;\r\n\r\n/** Simple TextView which is used to output log data received through the LogNode interface.\r\n*/\r\npublic class LogView extends TextView implements LogNode {\r\n\r\n public LogView(Context context) {\r\n super(context);\r\n }\r\n\r\n public LogView(Context context, AttributeSet attrs) {\r\n super(context, attrs);\r\n }\r\n\r\n public LogView(Context context, AttributeSet attrs, int defStyle) {\r\n super(context, attrs, defStyle);\r\n }\r\n\r\n /**\r\n * Formats the log data and prints it out to the LogView.\r\n * @param priority Log level of the data being logged. Verbose, Error, etc.\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged. The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n @Override\r\n public void println(int priority, String tag, String msg, Throwable tr) {\r\n\r\n \r\n String priorityStr = null;\r\n\r\n // For the purposes of this View, we want to print the priority as readable text.\r\n switch(priority) {\r\n case android.util.Log.VERBOSE:\r\n priorityStr = \"VERBOSE\";\r\n break;\r\n case android.util.Log.DEBUG:\r\n priorityStr = \"DEBUG\";\r\n break;\r\n case android.util.Log.INFO:\r\n priorityStr = \"INFO\";\r\n break;\r\n case android.util.Log.WARN:\r\n priorityStr = \"WARN\";\r\n break;\r\n case android.util.Log.ERROR:\r\n priorityStr = \"ERROR\";\r\n break;\r\n case android.util.Log.ASSERT:\r\n priorityStr = \"ASSERT\";\r\n break;\r\n default:\r\n break;\r\n }\r\n\r\n // Handily, the Log class has a facility for converting a stack trace into a usable string.\r\n String exceptionStr = null;\r\n if (tr != null) {\r\n exceptionStr = android.util.Log.getStackTraceString(tr);\r\n }\r\n\r\n // Take the priority, tag, message, and exception, and concatenate as necessary\r\n // into one usable line of text.\r\n final StringBuilder outputBuilder = new StringBuilder();\r\n\r\n String delimiter = \"\\t\";\r\n appendIfNotNull(outputBuilder, priorityStr, delimiter);\r\n appendIfNotNull(outputBuilder, tag, delimiter);\r\n appendIfNotNull(outputBuilder, msg, delimiter);\r\n appendIfNotNull(outputBuilder, exceptionStr, delimiter);\r\n\r\n // In case this was originally called from an AsyncTask or some other off-UI thread,\r\n // make sure the update occurs within the UI thread.\r\n ((Activity) getContext()).runOnUiThread( (new Thread(new Runnable() {\r\n @Override\r\n public void run() {\r\n // Display the text we just generated within the LogView.\r\n appendToLog(outputBuilder.toString());\r\n }\r\n })));\r\n\r\n if (mNext != null) {\r\n mNext.println(priority, tag, msg, tr);\r\n }\r\n }\r\n\r\n public LogNode getNext() {\r\n return mNext;\r\n }\r\n\r\n public void setNext(LogNode node) {\r\n mNext = node;\r\n }\r\n\r\n /** Takes a string and adds to it, with a separator, if the bit to be added isn't null. Since\r\n * the logger takes so many arguments that might be null, this method helps cut out some of the\r\n * agonizing tedium of writing the same 3 lines over and over.\r\n * @param source StringBuilder containing the text to append to.\r\n * @param addStr The String to append\r\n * @param delimiter The String to separate the source and appended strings. A tab or comma,\r\n * for instance.\r\n * @return The fully concatenated String as a StringBuilder\r\n */\r\n private StringBuilder appendIfNotNull(StringBuilder source, String addStr, String delimiter) {\r\n if (addStr != null) {\r\n if (addStr.length() == 0) {\r\n delimiter = \"\";\r\n }\r\n\r\n return source.append(addStr).append(delimiter);\r\n }\r\n return source;\r\n }\r\n\r\n // The next LogNode in the chain.\r\n LogNode mNext;\r\n\r\n /** Outputs the string as a new line of log data in the LogView. */\r\n public void appendToLog(String s) {\r\n append(\"\\n\" + s);\r\n }\r\n\r\n\r\n}\r\n"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/LogWrapper.java",
"content": "/*\r\n * Copyright (C) 2012 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\npackage com.stuffaboutcode.logger;\r\n\r\nimport android.util.Log;\r\n\r\n/**\r\n * Helper class which wraps Android's native Log utility in the Logger interface. This way\r\n * normal DDMS output can be one of the many targets receiving and outputting logs simultaneously.\r\n */\r\npublic class LogWrapper implements LogNode {\r\n\r\n // For piping: The next node to receive Log data after this one has done its work.\r\n private LogNode mNext;\r\n\r\n /**\r\n * Returns the next LogNode in the linked list.\r\n */\r\n public LogNode getNext() {\r\n return mNext;\r\n }\r\n\r\n /**\r\n * Sets the LogNode data will be sent to..\r\n */\r\n public void setNext(LogNode node) {\r\n mNext = node;\r\n }\r\n\r\n /**\r\n * Prints data out to the console using Android's native log mechanism.\r\n * @param priority Log level of the data being logged. Verbose, Error, etc.\r\n * @param tag Tag for for the log data. Can be used to organize log statements.\r\n * @param msg The actual message to be logged. The actual message to be logged.\r\n * @param tr If an exception was thrown, this can be sent along for the logging facilities\r\n * to extract and print useful information.\r\n */\r\n @Override\r\n public void println(int priority, String tag, String msg, Throwable tr) {\r\n // There actually are log methods that don't take a msg parameter. For now,\r\n // if that's the case, just convert null to the empty string and move on.\r\n String useMsg = msg;\r\n if (useMsg == null) {\r\n useMsg = \"\";\r\n }\r\n\r\n // If an exeption was provided, convert that exception to a usable string and attach\r\n // it to the end of the msg method.\r\n if (tr != null) {\r\n msg += \"\\n\" + Log.getStackTraceString(tr);\r\n }\r\n\r\n // This is functionally identical to Log.x(tag, useMsg);\r\n // For instance, if priority were Log.VERBOSE, this would be the same as Log.v(tag, useMsg)\r\n Log.println(priority, tag, useMsg);\r\n\r\n // If this isn't the last node in the chain, move things along.\r\n if (mNext != null) {\r\n mNext.println(priority, tag, msg, tr);\r\n }\r\n }\r\n}\r\n"
},
{
"path": "clients/android/app/src/main/java/com/stuffaboutcode/logger/MessageOnlyLogFilter.java",
"content": "/*\r\n * Copyright (C) 2013 The Android Open Source Project\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\npackage com.stuffaboutcode.logger;\r\n\r\n/**\r\n * Simple {@link LogNode} filter, removes everything except the message.\r\n * Useful for situations like on-screen log output where you don't want a lot of metadata displayed,\r\n * just easy-to-read message updates as they're happening.\r\n */\r\npublic class MessageOnlyLogFilter implements LogNode {\r\n\r\n LogNode mNext;\r\n\r\n /**\r\n * Takes the \"next\" LogNode as a parameter, to simplify chaining.\r\n *\r\n * @param next The next LogNode in the pipeline.\r\n */\r\n public MessageOnlyLogFilter(LogNode next) {\r\n mNext = next;\r\n }\r\n\r\n public MessageOnlyLogFilter() {\r\n }\r\n\r\n @Override\r\n public void println(int priority, String tag, String msg, Throwable tr) {\r\n if (mNext != null) {\r\n getNext().println(Log.NONE, null, msg, null);\r\n }\r\n }\r\n\r\n /**\r\n * Returns the next LogNode in the chain.\r\n */\r\n public LogNode getNext() {\r\n return mNext;\r\n }\r\n\r\n /**\r\n * Sets the LogNode data will be sent to..\r\n */\r\n public void setNext(LogNode node) {\r\n mNext = node;\r\n }\r\n\r\n}\r\n"
},
{
"path": "clients/android/app/src/main/res/drawable/round_button.xml",
"content": "\r\n\r\n- \r\n \r\n \r\n \r\n
\r\n- \r\n \r\n \r\n \r\n
\r\n"
},
{
"path": "clients/android/app/src/main/res/layout/activity_button.xml",
"content": "\r\n\r\n\r\n \r\n\r\n \r\n\r\n \r\n\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/layout/activity_devices.xml",
"content": "\r\n\r\n\r\n \r\n\r\n \r\n\r\n \r\n\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/layout/settings_activity.xml",
"content": "\n\n \n"
},
{
"path": "clients/android/app/src/main/res/menu/settings_menu.xml",
"content": "\n"
},
{
"path": "clients/android/app/src/main/res/values/arrays.xml",
"content": "\n \n - 1
\n - 2
\n - 3
\n - 4
\n - 5
\n - 6
\n - 7
\n - 8
\n - 9
\n - 10
\n - 11
\n - 12
\n - 13
\n - 14
\n - 15
\n - 16
\n - 17
\n - 18
\n - 19
\n - 20
\n - 21
\n - 22
\n - 23
\n - 24
\n - 25
\n - 26
\n - 27
\n - 28
\n - 29
\n - 30
\n \n"
},
{
"path": "clients/android/app/src/main/res/values/attrs.xml",
"content": "\n\n \n \n \n \n"
},
{
"path": "clients/android/app/src/main/res/values/colors.xml",
"content": "\r\n\r\n #3F51B5\r\n #303F9F\r\n #FF4081\r\n #FFFFFF\r\n #FF0000\r\n #0000FF\r\n #6d6d6e\r\n #0000FF\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/values/dimens.xml",
"content": "\r\n 16dp\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/values/strings.xml",
"content": "\r\n BlueButton\r\n Button\r\n Settings\r\n\r\n \r\n Messages\r\n Sync\r\n\r\n \r\n Your signature\r\n Default reply action\r\n\r\n \r\n Sync email periodically\r\n Download incoming attachments\r\n Automatically download attachments for incoming emails\r\n \r\n Only download attachments when manually requested\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/values/styles.xml",
"content": "\r\n\r\n \r\n \r\n\r\n \r\n\r\n \r\n\r\n \r\n\r\n\r\n"
},
{
"path": "clients/android/app/src/main/res/xml/root_preferences.xml",
"content": "\n\n\n\n \n\n \n \n\n \n\n\n"
},
{
"path": "clients/android/app/src/test/java/com/stuffaboutcode/bluedot/ExampleUnitTest.java",
"content": "package com.stuffaboutcode.bluedot;\r\n\r\nimport org.junit.Test;\r\n\r\nimport static org.junit.Assert.*;\r\n\r\n/**\r\n * Example local unit test, which will execute on the development machine (host).\r\n *\r\n * @see Testing documentation\r\n */\r\npublic class ExampleUnitTest {\r\n @Test\r\n public void addition_isCorrect() throws Exception {\r\n assertEquals(4, 2 + 2);\r\n }\r\n}"
},
{
"path": "clients/android/build.gradle",
"content": "// Top-level build file where you can add configuration options common to all sub-projects/modules.\r\n\r\nbuildscript {\r\n repositories {\r\n google()\r\n jcenter()\r\n }\r\n dependencies {\r\n classpath 'com.android.tools.build:gradle:7.3.1'\r\n\r\n // NOTE: Do not place your application dependencies here; they belong\r\n // in the individual module build.gradle files\r\n }\r\n}\r\n\r\n\r\nallprojects {\r\n repositories {\r\n google()\r\n jcenter()\r\n }\r\n}\r\n\r\ntask clean(type: Delete) {\r\n delete rootProject.buildDir\r\n}\r\n"
},
{
"path": "clients/android/gradle/wrapper/gradle-wrapper.properties",
"content": "#Fri Dec 23 09:57:24 GMT 2022\r\ndistributionBase=GRADLE_USER_HOME\r\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-7.4-bin.zip\r\ndistributionPath=wrapper/dists\r\nzipStorePath=wrapper/dists\r\nzipStoreBase=GRADLE_USER_HOME\r\n"
},
{
"path": "clients/android/gradle.properties",
"content": "# Project-wide Gradle settings.\r\n\r\n# IDE (e.g. Android Studio) users:\r\n# Gradle settings configured through the IDE *will override*\r\n# any settings specified in this file.\r\n\r\n# For more details on how to configure your build environment visit\r\n# http://www.gradle.org/docs/current/userguide/build_environment.html\r\n\r\n# Specifies the JVM arguments used for the daemon process.\r\n# The setting is particularly useful for tweaking memory settings.\r\nandroid.enableJetifier=true\r\nandroid.useAndroidX=true\r\norg.gradle.jvmargs=-Xmx1536m\r\n\r\n# When configured, Gradle will run in incubating parallel mode.\r\n# This option should only be used with decoupled projects. More details, visit\r\n# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects\r\n# org.gradle.parallel=true\r\n"
},
{
"path": "clients/android/gradlew",
"content": "#!/usr/bin/env bash\n\n##############################################################################\n##\n## Gradle start up script for UN*X\n##\n##############################################################################\n\n# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\nDEFAULT_JVM_OPTS=\"\"\n\nAPP_NAME=\"Gradle\"\nAPP_BASE_NAME=`basename \"$0\"`\n\n# Use the maximum available, or set MAX_FD != -1 to use that value.\nMAX_FD=\"maximum\"\n\nwarn ( ) {\n echo \"$*\"\n}\n\ndie ( ) {\n echo\n echo \"$*\"\n echo\n exit 1\n}\n\n# OS specific support (must be 'true' or 'false').\ncygwin=false\nmsys=false\ndarwin=false\ncase \"`uname`\" in\n CYGWIN* )\n cygwin=true\n ;;\n Darwin* )\n darwin=true\n ;;\n MINGW* )\n msys=true\n ;;\nesac\n\n# Attempt to set APP_HOME\n# Resolve links: $0 may be a link\nPRG=\"$0\"\n# Need this for relative symlinks.\nwhile [ -h \"$PRG\" ] ; do\n ls=`ls -ld \"$PRG\"`\n link=`expr \"$ls\" : '.*-> \\(.*\\)$'`\n if expr \"$link\" : '/.*' > /dev/null; then\n PRG=\"$link\"\n else\n PRG=`dirname \"$PRG\"`\"/$link\"\n fi\ndone\nSAVED=\"`pwd`\"\ncd \"`dirname \\\"$PRG\\\"`/\" >/dev/null\nAPP_HOME=\"`pwd -P`\"\ncd \"$SAVED\" >/dev/null\n\nCLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar\n\n# Determine the Java command to use to start the JVM.\nif [ -n \"$JAVA_HOME\" ] ; then\n if [ -x \"$JAVA_HOME/jre/sh/java\" ] ; then\n # IBM's JDK on AIX uses strange locations for the executables\n JAVACMD=\"$JAVA_HOME/jre/sh/java\"\n else\n JAVACMD=\"$JAVA_HOME/bin/java\"\n fi\n if [ ! -x \"$JAVACMD\" ] ; then\n die \"ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\n fi\nelse\n JAVACMD=\"java\"\n which java >/dev/null 2>&1 || die \"ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\n\nPlease set the JAVA_HOME variable in your environment to match the\nlocation of your Java installation.\"\nfi\n\n# Increase the maximum file descriptors if we can.\nif [ \"$cygwin\" = \"false\" -a \"$darwin\" = \"false\" ] ; then\n MAX_FD_LIMIT=`ulimit -H -n`\n if [ $? -eq 0 ] ; then\n if [ \"$MAX_FD\" = \"maximum\" -o \"$MAX_FD\" = \"max\" ] ; then\n MAX_FD=\"$MAX_FD_LIMIT\"\n fi\n ulimit -n $MAX_FD\n if [ $? -ne 0 ] ; then\n warn \"Could not set maximum file descriptor limit: $MAX_FD\"\n fi\n else\n warn \"Could not query maximum file descriptor limit: $MAX_FD_LIMIT\"\n fi\nfi\n\n# For Darwin, add options to specify how the application appears in the dock\nif $darwin; then\n GRADLE_OPTS=\"$GRADLE_OPTS \\\"-Xdock:name=$APP_NAME\\\" \\\"-Xdock:icon=$APP_HOME/media/gradle.icns\\\"\"\nfi\n\n# For Cygwin, switch paths to Windows format before running java\nif $cygwin ; then\n APP_HOME=`cygpath --path --mixed \"$APP_HOME\"`\n CLASSPATH=`cygpath --path --mixed \"$CLASSPATH\"`\n JAVACMD=`cygpath --unix \"$JAVACMD\"`\n\n # We build the pattern for arguments to be converted via cygpath\n ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`\n SEP=\"\"\n for dir in $ROOTDIRSRAW ; do\n ROOTDIRS=\"$ROOTDIRS$SEP$dir\"\n SEP=\"|\"\n done\n OURCYGPATTERN=\"(^($ROOTDIRS))\"\n # Add a user-defined pattern to the cygpath arguments\n if [ \"$GRADLE_CYGPATTERN\" != \"\" ] ; then\n OURCYGPATTERN=\"$OURCYGPATTERN|($GRADLE_CYGPATTERN)\"\n fi\n # Now convert the arguments - kludge to limit ourselves to /bin/sh\n i=0\n for arg in \"$@\" ; do\n CHECK=`echo \"$arg\"|egrep -c \"$OURCYGPATTERN\" -`\n CHECK2=`echo \"$arg\"|egrep -c \"^-\"` ### Determine if an option\n\n if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition\n eval `echo args$i`=`cygpath --path --ignore --mixed \"$arg\"`\n else\n eval `echo args$i`=\"\\\"$arg\\\"\"\n fi\n i=$((i+1))\n done\n case $i in\n (0) set -- ;;\n (1) set -- \"$args0\" ;;\n (2) set -- \"$args0\" \"$args1\" ;;\n (3) set -- \"$args0\" \"$args1\" \"$args2\" ;;\n (4) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" ;;\n (5) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" ;;\n (6) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" ;;\n (7) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" ;;\n (8) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" ;;\n (9) set -- \"$args0\" \"$args1\" \"$args2\" \"$args3\" \"$args4\" \"$args5\" \"$args6\" \"$args7\" \"$args8\" ;;\n esac\nfi\n\n# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules\nfunction splitJvmOpts() {\n JVM_OPTS=(\"$@\")\n}\neval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS\nJVM_OPTS[${#JVM_OPTS[*]}]=\"-Dorg.gradle.appname=$APP_BASE_NAME\"\n\nexec \"$JAVACMD\" \"${JVM_OPTS[@]}\" -classpath \"$CLASSPATH\" org.gradle.wrapper.GradleWrapperMain \"$@\"\n"
},
{
"path": "clients/android/gradlew.bat",
"content": "@if \"%DEBUG%\" == \"\" @echo off\r\n@rem ##########################################################################\r\n@rem\r\n@rem Gradle startup script for Windows\r\n@rem\r\n@rem ##########################################################################\r\n\r\n@rem Set local scope for the variables with windows NT shell\r\nif \"%OS%\"==\"Windows_NT\" setlocal\r\n\r\n@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.\r\nset DEFAULT_JVM_OPTS=\r\n\r\nset DIRNAME=%~dp0\r\nif \"%DIRNAME%\" == \"\" set DIRNAME=.\r\nset APP_BASE_NAME=%~n0\r\nset APP_HOME=%DIRNAME%\r\n\r\n@rem Find java.exe\r\nif defined JAVA_HOME goto findJavaFromJavaHome\r\n\r\nset JAVA_EXE=java.exe\r\n%JAVA_EXE% -version >NUL 2>&1\r\nif \"%ERRORLEVEL%\" == \"0\" goto init\r\n\r\necho.\r\necho ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:findJavaFromJavaHome\r\nset JAVA_HOME=%JAVA_HOME:\"=%\r\nset JAVA_EXE=%JAVA_HOME%/bin/java.exe\r\n\r\nif exist \"%JAVA_EXE%\" goto init\r\n\r\necho.\r\necho ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%\r\necho.\r\necho Please set the JAVA_HOME variable in your environment to match the\r\necho location of your Java installation.\r\n\r\ngoto fail\r\n\r\n:init\r\n@rem Get command-line arguments, handling Windowz variants\r\n\r\nif not \"%OS%\" == \"Windows_NT\" goto win9xME_args\r\nif \"%@eval[2+2]\" == \"4\" goto 4NT_args\r\n\r\n:win9xME_args\r\n@rem Slurp the command line arguments.\r\nset CMD_LINE_ARGS=\r\nset _SKIP=2\r\n\r\n:win9xME_args_slurp\r\nif \"x%~1\" == \"x\" goto execute\r\n\r\nset CMD_LINE_ARGS=%*\r\ngoto execute\r\n\r\n:4NT_args\r\n@rem Get arguments from the 4NT Shell from JP Software\r\nset CMD_LINE_ARGS=%$\r\n\r\n:execute\r\n@rem Setup the command line\r\n\r\nset CLASSPATH=%APP_HOME%\\gradle\\wrapper\\gradle-wrapper.jar\r\n\r\n@rem Execute Gradle\r\n\"%JAVA_EXE%\" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% \"-Dorg.gradle.appname=%APP_BASE_NAME%\" -classpath \"%CLASSPATH%\" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%\r\n\r\n:end\r\n@rem End local scope for the variables with windows NT shell\r\nif \"%ERRORLEVEL%\"==\"0\" goto mainEnd\r\n\r\n:fail\r\nrem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of\r\nrem the _cmd.exe /c_ return code!\r\nif not \"\" == \"%GRADLE_EXIT_CONSOLE%\" exit 1\r\nexit /b 1\r\n\r\n:mainEnd\r\nif \"%OS%\"==\"Windows_NT\" endlocal\r\n\r\n:omega\r\n"
},
{
"path": "clients/android/settings.gradle",
"content": "include ':app'\r\n"
},
{
"path": "clients/python/README.rst",
"content": "Blue Dot Python App\n===================\n\nBlue Dot Python app allows you to use another Raspberry Pi (or linux based computer) as the Blue Dot remote.\n\n|bluedotpython| |bluedotpythondevices|\n\nStart\n-----\n\nThe app is included in the bluedot Python library:\n\n1. If you havent already done so, pair your raspberry pi and install the Python library as described in the `getting started`_ guide\n2. Run the Blue Dot app::\n\n bluedotapp\n\n4. Select your Raspberry Pi from the paired devices list\n\n|bluedotpythondevices|\n\n5. Press the Dot\n\n|bluedotpython|\n\nOptions\n-------\n\nTo get help with the Blue Dot app options::\n\n bluedotapp --help\n\nIf you have more than 1 bluetooth device you can use ``--device`` to use a particular device::\n\n bluedotapp --device hci1\n\nYou can specify the server to connect to at startup by using the ``--server`` option::\n\n bluedotapp --server myraspberrypi\n\nIf you are using a different port you can specify it using the ``--port`` option::\n\n bluedotapp --port 1\n\nThe screen size of the Blue Dot app can be changed using the ``width`` and ``height`` options and specifying the number of pixels::\n\n bluedotapp --width 500 --height 500\n\nThe app can also be used full screen, if no ``width`` or ``height`` is given the screen will be sized to the current resolution of the screen::\n\n bluedotapp --fullscreen\n\n.. _getting started: http://bluedot.readthedocs.io/en/latest/gettingstarted.html\n\n.. |bluedotpython| image:: https://raw.githubusercontent.com/martinohanlon/BlueDot/master/docs/images/bluedotpython.png\n :height: 274 px\n :width: 324 px\n :scale: 100 %\n :alt: blue dot python app\n\n.. |bluedotpythondevices| image:: https://raw.githubusercontent.com/martinohanlon/BlueDot/master/docs/images/bluedotpythondevices.png\n :height: 273 px\n :width: 326 px\n :scale: 100 %\n :alt: blue dot devices\n"
},
{
"path": "docs/Makefile",
"content": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS =\nSPHINXBUILD = sphinx-build\nSPHINXPROJ = bluedot\nSOURCEDIR = .\nBUILDDIR = _build\n\n# Put it first so that \"make\" without argument is like \"make help\".\nhelp:\n\t@$(SPHINXBUILD) -M help \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)\n\n.PHONY: help Makefile\n\n# Catch-all target: route all unknown targets to Sphinx using the new\n# \"make mode\" option. $(O) is meant as a shortcut for $(SPHINXOPTS).\n%: Makefile\n\t@$(SPHINXBUILD) -M $@ \"$(SOURCEDIR)\" \"$(BUILDDIR)\" $(SPHINXOPTS) $(O)"
},
{
"path": "docs/bluedotandroidapp.rst",
"content": "Blue Dot Android App\n====================\n\nThe `Blue Dot app`_ is available to download from the Google Play store.\n\nPlease leave a rating and review if you find Blue Dot useful :)\n\n|bluedotapp| |bluedotappdevices|\n\nStart\n-----\n\n1. Download the `Blue Dot app`_ from the Google Play store.\n\n2. If you havent already done so, pair your raspberry pi as described in the\n :doc:`gettingstarted` guide.\n\n3. Run the Blue Dot app\n\n |bluedotappicon|\n\n4. Select your Raspberry Pi from the paired devices list\n\n |bluedotappdevices|\n\n5. Press the Dot\n\n |bluedotapp|\n\n.. _Blue Dot app: http://play.google.com/store/apps/details?id=com.stuffaboutcode.bluedot\n\n.. |bluedotapp| image:: images/bluedotandroid_small.png\n :alt: Screenshot of Blue Dot app\n\n.. |bluedotappdevices| image:: images/bluedotandroiddevices_small.png\n :alt: Screenshot of Blue Dot devices list screen\n\n.. |bluedotappicon| image:: images/bluedotandroidicon.png\n :alt: Blue Dot icon\n"
},
{
"path": "docs/bluedotpythonapp.rst",
"content": "Blue Dot Python App\n===================\n\nBlue Dot Python app allows you to use another Raspberry Pi (or linux based computer) as the Blue Dot remote.\n\n|bluedotpython| |bluedotpythondevices|\n\nStart\n-----\n\nThe app is included in the bluedot Python library:\n\n1. If you havent already done so, pair your raspberry pi and install the Python\n library as described in the :doc:`gettingstarted` guide\n\n2. Run the Blue Dot app::\n\n bluedotapp\n\n3. Select your Raspberry Pi from the paired devices list\n\n |bluedotpythondevices|\n\n4. Press the Dot\n\n |bluedotpython|\n\nOptions\n-------\n\nTo get help with the Blue Dot app options::\n\n bluedotapp --help\n\nIf you have more than 1 bluetooth device you can use ``--device`` to use a particular device::\n\n bluedotapp --device hci1\n\nYou can specify the server to connect to at startup by using the ``--server`` option::\n\n bluedotapp --server myraspberrypi\n\nThe screen size of the Blue Dot app can be changed using the ``width`` and ``height`` options and specifying the number of pixels::\n\n bluedotapp --width 500 --height 500\n\nThe app can also be used full screen, if no ``width`` or ``height`` is given the screen will be sized to the current resolution of the screen::\n\n bluedotapp --fullscreen\n\n.. |bluedotpython| image:: images/bluedotpython.png\n :alt: Screenshot of Blue Dot python app\n\n.. |bluedotpythondevices| image:: images/bluedotpythondevices.png\n :alt: Screenshot of Blue Dot devices list\n"
},
{
"path": "docs/btcommapi.rst",
"content": "Bluetooth Comm API\n==================\n\nBlue Dot also contains a useful :mod:`btcomm` API for sending and\nreceiving data over Bluetooth.\n\nFor normal use of Blue Dot, this API doesn't need to be used, but its included\nin the documentation for info and for those who might need a simple Bluetooth\ncommunication library.\n\n.. module:: bluedot.btcomm\n\nBluetoothServer\n---------------\n\n.. autoclass:: BluetoothServer\n\nBluetoothClient\n---------------\n\n.. autoclass:: BluetoothClient\n\nBluetoothAdapter\n----------------\n\n.. autoclass:: BluetoothAdapter\n\n"
},
{
"path": "docs/build.rst",
"content": "Build\r\n=====\r\n\r\nThese are instructions for how to develop, build and deploy Blue Dot.\r\n\r\nDevelop\r\n-------\r\n\r\nInstall / upgrade tools::\r\n\r\n sudo python3 -m pip install --upgrade pip setuptools wheel twine virtualenv\r\n\r\nCreate a virtual environment (recommended)::\r\n\r\n virtualenv --system-site-packages bluedot-dev\r\n cd bluedot-dev\r\n source bin/activate \r\n\r\nClone repo and install for dev::\r\n\r\n git clone https://github.com/martinohanlon/BlueDot\r\n cd BlueDot\r\n git checkout dev\r\n python3 setup.py develop\r\n\r\nTest\r\n----\r\n\r\nInstall `pytest`_::\r\n\r\n pip3 install -U pytest\r\n\r\nRun tests::\r\n\r\n cd BlueDot/tests\r\n pytest -v\r\n\r\nDeploy\r\n------\r\n\r\nBuild for deployment::\r\n\r\n python3 setup.py sdist\r\n python3 setup.py bdist_wheel\r\n\r\nDeploy to `PyPI`_::\r\n\r\n twine upload dist/* --skip-existing\r\n\r\n\r\n.. _pytest: https://doc.pytest.org/\r\n.. _PyPI: https://pypi.python.org/pypi\r\n"
},
{
"path": "docs/changelog.rst",
"content": "Change log\n==========\n\n.. currentmodule:: bluedot\n\nBluedot Python library\n----------------------\n\n2.0.0 - 2020-11-01\n~~~~~~~~~~~~~~~~~~\n\n * implementation of multiple buttons in a matrix\n * refactor of significant portions of the code base\n * improvement to btcomm to manage large messages \n * update to MockBlueDot\n * deprecated BlueDot.interaction\n * added warnings when invalid data is received\n * support for protocol version 2\n * removed support for Python 2, 3.3 & 3.4\n\n1.3.2 - 2019-04-22\n~~~~~~~~~~~~~~~~~~\n\n * change to how callbacks are called\n * added `set_when_pressed`, `set_when_released`, etc to allow callbacks to be called in their own threads.\n\n1.3.1 - 2019-01-01\n~~~~~~~~~~~~~~~~~~\n\n * minor bug fix to launch_mock_app\n\n1.3.0 - 2018-12-30\n~~~~~~~~~~~~~~~~~~\n\n * added ability to change the color, border, shape and visibility of the dot (:attr:`~BlueDot.color`, :attr:`~BlueDot.border`, :attr:`~BlueDot.square`, :attr:`~BlueDot.visible`)\n * added protocol version checking\n * minor threading changes in btcomm\n * updates to the Blue Dot Python app\n * rewrite of the mock app\n * support for protocol version 1\n \n1.2.3 - 2018-02-22\n~~~~~~~~~~~~~~~~~~\n\n * fix to `wait_for_press` and `wait_for_release`\n * when_client_connects and when_client_disconnects callbacks are now threaded\n * The python blue dot app can now be started with the command `bluedotapp`\n * new tests for `wait_for_(events)`\n\n1.2.2 - 2017-12-30\n~~~~~~~~~~~~~~~~~~\n\n * bluetooth comms tests and minor bug fix in :class:`~.btcomm.BluetoothClient`\n\n1.2.1 - 2017-12-18\n~~~~~~~~~~~~~~~~~~\n\n * massive code and docs tidy up by `Dave Jones`_\n\n1.2.0 - 2017-12-10\n~~~~~~~~~~~~~~~~~~\n\n * added when_rotated\n * threaded swipe callbacks\n * exposed new :class:`BlueDot` properties (:attr:`~BlueDot.adapter`, :attr:`~BlueDot.running`, :attr:`~BlueDot.paired_devices`)\n * fixed active bug in interaction\n * automated tests\n\n1.1.0 - 2017-11-05\n~~~~~~~~~~~~~~~~~~\n\n * threaded callbacks\n * python app rounded x,y performance improvements\n\n1.0.4 - 2017-09-10\n~~~~~~~~~~~~~~~~~~\n\n * serial port profile port fix\n * launching multiple blue dots fix\n\n1.0.3 - 2017-07-28\n~~~~~~~~~~~~~~~~~~\n\n * python 2 bug fix\n\n1.0.2 - 2017-07-23\n~~~~~~~~~~~~~~~~~~\n\n * bug fix\n\n1.0.1 - 2017-06-19\n~~~~~~~~~~~~~~~~~~\n\n * bug fixes\n\n1.0.0 - 2017-06-04\n~~~~~~~~~~~~~~~~~~\n\n * production release!\n * added double click\n * doc updates\n * minor changes\n\n0.4.0 - 2017-05-05\n~~~~~~~~~~~~~~~~~~\n\n * added swipes and interactions\n * doc updates\n * bug fix in :attr:`BlueDot.when_moved`\n\n0.3.0 - 2017-05-01\n~~~~~~~~~~~~~~~~~~\n\n * Python Blue Dot app\n * minor bug fix in :class:`~.btcomm.BluetoothClient`\n\n0.2.1 - 2017-04-23\n~~~~~~~~~~~~~~~~~~\n\n * bug fix in :class:`MockBlueDot`\n * doc fixes\n\n0.2.0 - 2017-04-23\n~~~~~~~~~~~~~~~~~~\n\n * added :attr:`~BlueDot.when_client_connects`, :attr:`~BlueDot.when_client_disconnects`\n * added :meth:`~BlueDot.allow_pairing` functions\n * refactored Bluetooth comms\n * added :class:`~.btcomm.BluetoothAdapter`\n\n0.1.2 - 2017-04-14\n~~~~~~~~~~~~~~~~~~\n\n * mock blue dot improvements\n * doc fixes\n\n0.1.1 - 2017-04-08\n~~~~~~~~~~~~~~~~~~\n\n * clamped distance in :class:`BlueDotPosition`\n\n0.1.0 - 2017-04-07\n~~~~~~~~~~~~~~~~~~\n\n * Check Bluetooth adapter is powered\n * Handle client connection timeouts\n * Docs & image updates\n\n0.0.6 - 2017-04-05\n~~~~~~~~~~~~~~~~~~\n\n * Added :class:`MockBlueDot` for testing and debugging\n * more docs\n\n0.0.4 - 2017-03-31\n~~~~~~~~~~~~~~~~~~\n\nUpdates after alpha feedback\n\n * Python 2 compatibility\n * ``.dot_position`` to ``.position``\n * ``.values`` added\n * clamped ``x``, ``y`` to 1\n * loads of doc updates\n\n0.0.2 - 2017-03-29\n~~~~~~~~~~~~~~~~~~\n\nAlpha - initial testing\n\nAndroid app\n-----------\n\n10 (2.2.1) - 2022-01-03\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Android 12+ fixes\n\n9 (2.2) - 2022-12-23\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Android SDK and API version uplift (due to google play store minimum requirements change)\n\n8 (2.1) - 2020-12-28\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * removed \"auto port discovery\" after the introduction of pulseaudio to Raspberry Pi OS broke it\n * introduced the \"default port\" setting as an alternative\n\n7 (2.0) - 2020-11-01\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * implementation of multiple buttons in a matrix\n * support for protocol version 2\n\n6 (1.3.1) - 2019-12-30\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Minor bug fix\n\n5 (1.3) - 2019-12-29\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Added settings menu so a specific bluetooth port can be selected\n * Using specific bluetooth ports, multiple apps can now connect to a single BT devices\n * Minor bugs fixes\n\n4 (1.2) - 2018-12-30\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Rewrite of the Button view\n * Rewrite of the Bluetooth comms layer\n * Support for colours, square and border\n * Landscape (and portrait) views\n * added protocol version checking\n * support for protocol version 1\n\n3 (1.1.1) - 2018-09-21\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * Android SDK version uplift (due to google play store minimum requirements change)\n\n2 (1.1) - 2017-11-05\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * better responsive layout\n * fixed issues with small screen devices\n * rounded x,y values increasing performance\n * new help icon\n * link to https://bluedot.readthedocs.io not http\n\n1 (0.0.2) - 2017-04-05\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * icon transparency\n * connection monitor\n * added info icon to https://bluedot.readthedocs.io\n\n0 (0.0.1) - 2017-03-29\n~~~~~~~~~~~~~~~~~~~~~~~~\n\n * alpha - initial testing\n\n.. _Dave Jones: https://github.com/waveform80"
},
{
"path": "docs/conf.py",
"content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n#\n# bluedot documentation build configuration file, created by\n# sphinx-quickstart on Mon Mar 27 21:11:18 2017.\n#\n# This file is execfile()d with the current directory set to its\n# containing dir.\n#\n# Note that not all possible configuration values are present in this\n# autogenerated file.\n#\n# All configuration values have a default; values that are commented out\n# serve to show the default.\n\n# If extensions (or modules to document with autodoc) are in another directory,\n# add these directories to sys.path here. If the directory is relative to the\n# documentation root, use os.path.abspath to make it absolute, like shown here.\n#\nimport os\nimport sys\nfrom datetime import datetime\nsys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))\non_rtd = os.environ.get('READTHEDOCS', None) == 'True'\nimport setup as _setup\n\n# Mock out certain modules while building documentation\nclass Mock:\n __all__ = []\n def __init__(self, *args, **kw): pass\n def __call__(self, *args, **kw): return Mock()\n def __mul__(self, other): return Mock()\n def __and__(self, other): return Mock()\n def __bool__(self): return False\n def __nonzero__(self): return False\n @classmethod\n def __getattr__(cls, name):\n if name in ('__file__', '__path__'):\n return '/dev/null'\n else:\n return Mock()\n\nsys.modules['dbus'] = Mock()\n\n\n# -- General configuration ------------------------------------------------\n\n# If your documentation needs a minimal Sphinx version, state it here.\n#\n# needs_sphinx = '1.0'\n\n# Add any Sphinx extension module names here, as strings. They can be\n# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom\n# ones.\nextensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.intersphinx']\n\n# Add any paths that contain templates here, relative to this directory.\ntemplates_path = ['_templates']\n\n# The suffix(es) of source filenames.\n# You can specify multiple suffix as a list of string:\n#\n# source_suffix = ['.rst', '.md']\nsource_suffix = '.rst'\n\n# The master toctree document.\nmaster_doc = 'index'\n\n# General information about the project.\nproject = _setup.__project__\nauthor = _setup.__author__\ncopyright = \"%d %s\" % (datetime.now().year, author)\n\n# The version info for the project you're documenting, acts as replacement for\n# |version| and |release|, also used in various other places throughout the\n# built documents.\n#\n# The short X.Y version.\nversion = _setup.__version__\n# The full version, including alpha/beta/rc tags.\nrelease = _setup.__version__\n\n# The language for content autogenerated by Sphinx. Refer to documentation\n# for a list of supported languages.\n#\n# This is also used if you do content translation via gettext catalogs.\n# Usually you set \"language\" from the command line for these cases.\nlanguage = None\n\n# List of patterns, relative to source directory, that match files and\n# directories to ignore when looking for source files.\n# This patterns also effect to html_static_path and html_extra_path\nexclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']\n\n# The name of the Pygments (syntax highlighting) style to use.\npygments_style = 'sphinx'\n\n# If true, `todo` and `todoList` produce output, else they produce nothing.\ntodo_include_todos = False\n\n\n# -- Autodoc configuration ------------------------------------------------\n\nautodoc_member_order = 'groupwise'\nautodoc_default_flags = ['members']\n\n# -- Intersphinx configuration --------------------------------------------\n\nintersphinx_mapping = {\n 'python': ('https://docs.python.org/3.5', None),\n 'gpiozero': ('https://gpiozero.readthedocs.io/en/latest', None),\n 'picamera': ('https://picamera.readthedocs.io/en/latest', None),\n }\n\n# -- Options for HTML output ----------------------------------------------\n\n# The theme to use for HTML and HTML Help pages. See the documentation for\n# a list of builtin themes.\n#\nif on_rtd:\n html_theme = 'sphinx_rtd_theme'\n #html_theme_options = {}\n html_sidebars = {\n '**': [\n 'globaltoc.html',\n 'relations.html',\n 'searchbox.html',\n ],\n }\nelse:\n html_theme = 'default'\n #html_theme_options = {}\n #html_sidebars = {}\n\nhtml_title = '%s %s Documentation' % (project, version)\n\n# Add any paths that contain custom static files (such as style sheets) here,\n# relative to this directory. They are copied after the builtin static files,\n# so a file named \"default.css\" will overwrite the builtin \"default.css\".\nhtml_static_path = ['_static']\n\nsuppress_warnings = ['image.nonlocal_uri']\n\n\n# -- Options for HTMLHelp output ------------------------------------------\n\n# Output file base name for HTML help builder.\nhtmlhelp_basename = '%sdoc' % project\n\n\n# -- Options for LaTeX output ---------------------------------------------\n\nlatex_elements = {\n 'papersize': 'a4paper',\n 'pointsize': '10pt',\n 'preamble': r'\\def\\thempfootnote{\\arabic{mpfootnote}}', # workaround sphinx issue #2530\n}\n\n# Grouping the document tree into LaTeX files. List of tuples\n# (source start file, target name, title,\n# author, documentclass [howto, manual, or own class]).\nlatex_documents = [\n (\n 'index', # source start file\n '%s.tex' % _setup.__project__, # target filename\n '%s Documentation' % project, # title\n _setup.__author__, # author\n 'manual', # documentclass\n True, # documents ref'd from toctree only\n ),\n]\n\nlatex_show_pagerefs = True\nlatex_show_urls = 'footnote'\n\n\n# -- Options for epub output ----------------------------------------------\n\nepub_basename = project\n#epub_theme = 'epub'\n#epub_title = html_title\nepub_author = author\nepub_identifier = 'https://bluedot.readthedocs.io/'\n#epub_tocdepth = 3\nepub_show_urls = 'no'\n#epub_use_index = True\n\n# -- Options for manual page output ---------------------------------------\n\n# One entry per manual page. List of tuples\n# (source start file, name, description, authors, manual section).\nman_pages = [\n (master_doc, project, '%s Documentation' % project, [author], 1)\n]\n\n# -- Options for Texinfo output -------------------------------------------\n\n# Grouping the document tree into Texinfo files. List of tuples\n# (source start file, target name, title, author,\n# dir menu entry, description, category)\ntexinfo_documents = []\n"
},
{
"path": "docs/dotapi.rst",
"content": "Blue Dot API\n============\n\n.. module:: bluedot\n\nBlueDot\n-------\n\n.. autoclass:: BlueDot\n\nBlueDotButton\n-------------\n\n.. autoclass:: BlueDotButton\n\nBlueDotPosition\n---------------\n\n.. autoclass:: BlueDotPosition\n\nBlueDotInteraction\n------------------\n\n.. autoclass:: BlueDotInteraction\n\nBlueDotSwipe\n------------\n\n.. autoclass:: BlueDotSwipe\n\nBlueDotRotation\n---------------\n\n.. autoclass:: BlueDotRotation\n"
},
{
"path": "docs/examples/bt_enumerate.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\n\ndevices = bd.paired_devices\nfor d in devices:\n device_address = d[0]\n device_name = d[1]\n"
},
{
"path": "docs/examples/bt_pair_button.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import Button\nfrom signal import pause\n\nbd = BlueDot()\nbutton = Button(27)\n\nbutton.when_pressed = bd.allow_pairing\n\npause()\n"
},
{
"path": "docs/examples/bt_pairing.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\nbd = BlueDot()\nbd.allow_pairing()\n\npause()\n"
},
{
"path": "docs/examples/camera.py",
"content": "from bluedot import BlueDot\nfrom picamera import PiCamera\nfrom signal import pause\n\nbd = BlueDot()\ncam = PiCamera()\n\ndef take_picture():\n cam.capture(\"pic.jpg\")\n\nbd.when_pressed = take_picture\n\npause()\n"
},
{
"path": "docs/examples/dpad.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef dpad(pos):\n if pos.top:\n print(\"up\")\n elif pos.bottom:\n print(\"down\")\n elif pos.left:\n print(\"left\")\n elif pos.right:\n print(\"right\")\n elif pos.middle:\n print(\"fire\")\n\nbd = BlueDot()\nbd.when_pressed = dpad\n\npause()\n"
},
{
"path": "docs/examples/dpad_layout.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef up():\r\n print(\"up\")\r\n\r\ndef down():\r\n print(\"down\")\r\n\r\ndef left():\r\n print(\"left\")\r\n\r\ndef right():\r\n print(\"right\")\r\n\r\nbd = BlueDot(cols=3, rows=3)\r\nbd.color = \"gray\"\r\nbd.square = True\r\n\r\nbd[0,0].visible = False\r\nbd[2,0].visible = False\r\nbd[0,2].visible = False\r\nbd[2,2].visible = False\r\nbd[1,1].visible = False\r\n\r\nbd[1,0].when_pressed = up\r\nbd[1,2].when_pressed = down\r\nbd[0,1].when_pressed = left\r\nbd[2,1].when_pressed = right\r\n\r\npause()"
},
{
"path": "docs/examples/goodbye_world.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef say_hello():\n print(\"Hello World\")\n\ndef say_goodbye():\n print(\"goodbye\")\n\nbd = BlueDot()\nbd.when_pressed = say_hello\nbd.when_released = say_goodbye\n\npause()\n"
},
{
"path": "docs/examples/hello_event.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef say_hello():\n print(\"Hello World\")\n\nbd = BlueDot()\nbd.when_pressed = say_hello\n\npause()\n"
},
{
"path": "docs/examples/hello_world.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.wait_for_press()\nprint(\"Hello World\")\n"
},
{
"path": "docs/examples/joypad.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef up():\r\n print(\"up\")\r\n\r\ndef down():\r\n print(\"down\")\r\n\r\ndef left():\r\n print(\"left\")\r\n\r\ndef right():\r\n print(\"right\")\r\n\r\ndef button_A():\r\n print(\"A\")\r\n\r\ndef button_B():\r\n print(\"B\")\r\n\r\nbd = BlueDot(cols=5, rows=3)\r\n\r\n# dpad buttons\r\nbd.color = \"gray\"\r\nbd.square = True\r\nbd[0,0].visible = False\r\nbd[2,0].visible = False\r\nbd[0,2].visible = False\r\nbd[2,2].visible = False\r\nbd[1,1].visible = False\r\n\r\nbd[1,0].when_pressed = up\r\nbd[1,2].when_pressed = down\r\nbd[0,1].when_pressed = left\r\nbd[2,1].when_pressed = right\r\n\r\n# buttons\r\nbd[3,0].visible = False\r\nbd[4,0].visible = False\r\nbd[3,2].visible = False\r\nbd[4,2].visible = False\r\n\r\nbd[3,1].color = \"blue\"\r\nbd[3,1].square = False\r\nbd[3,1].when_pressed = button_A\r\n\r\nbd[4,1].color = \"red\"\r\nbd[4,1].when_pressed = button_B\r\n\r\npause()"
},
{
"path": "docs/examples/led1.py",
"content": "import os\nfrom bluedot import BlueDot\nfrom gpiozero import LED\n\nbd = BlueDot()\nled = LED(27)\n\nbd.wait_for_press()\nled.on()\n\nbd.wait_for_release()\nled.off()\n"
},
{
"path": "docs/examples/led2.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import LED\nfrom signal import pause\n\nbd = BlueDot()\nled = LED(27)\n\nbd.when_pressed = led.on\nbd.when_released = led.off\n\npause()\n"
},
{
"path": "docs/examples/led3.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import LED\nfrom signal import pause\n\nbd = BlueDot()\nled = LED(27)\n\nled.source = bd.values\n\npause()\n"
},
{
"path": "docs/examples/looks_border.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.border = True"
},
{
"path": "docs/examples/looks_color.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.color = \"red\""
},
{
"path": "docs/examples/looks_square.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.square = True"
},
{
"path": "docs/examples/looks_visible.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.visible = False"
},
{
"path": "docs/examples/many_buttons.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=2, rows=5)\r\nbd.when_pressed = pressed\r\n\r\npause()"
},
{
"path": "docs/examples/many_buttons_random_colors.py",
"content": "from bluedot import BlueDot, COLORS\r\nfrom random import choice\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=2, rows=5)\r\nbd.when_pressed = pressed\r\n\r\nfor button in bd.buttons:\r\n button.color = choice(list(COLORS.values()))\r\n\r\npause()"
},
{
"path": "docs/examples/mock_app.py",
"content": "from bluedot import MockBlueDot\nfrom signal import pause\n\ndef say_hello():\n print(\"Hello World\")\n\nbd = MockBlueDot()\nbd.when_pressed = say_hello\n\nbd.launch_mock_app()\npause()\n"
},
{
"path": "docs/examples/mock_script.py",
"content": "from bluedot import MockBlueDot\n\ndef say_hello():\n print(\"Hello World\")\n\nbd = MockBlueDot()\nbd.when_pressed = say_hello\n\nbd.mock_client_connected()\nbd.mock_blue_dot_pressed(0,0)\n"
},
{
"path": "docs/examples/multiple_dots.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef bd1_pressed():\n print(\"BlueDot 1 pressed\")\n\ndef bd2_pressed():\n print(\"BlueDot 2 pressed\")\n\nbd1 = BlueDot(port = 1)\nbd2 = BlueDot(port = 2)\n\nbd1.when_pressed = bd1_pressed\nbd2.when_pressed = bd2_pressed\n\npause()\n"
},
{
"path": "docs/examples/robot1.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import Robot\nfrom signal import pause\n\nbd = BlueDot()\nrobot = Robot(left=(17, 18), right=(22, 23))\n\ndef move(pos):\n if pos.top:\n robot.forward()\n elif pos.bottom:\n robot.backward()\n elif pos.left:\n robot.left()\n elif pos.right:\n robot.right()\n\ndef stop():\n robot.stop()\n\nbd.when_pressed = move\nbd.when_moved = move\nbd.when_released = stop\n\npause()\n"
},
{
"path": "docs/examples/robot2.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import Robot\nfrom signal import pause\n\nbd = BlueDot()\nrobot = Robot(left=(lfpin, lbpin), right=(rfpin, rbpin))\n\ndef move(pos):\n if pos.top:\n robot.forward(pos.distance)\n elif pos.bottom:\n robot.backward(pos.distance)\n elif pos.left:\n robot.left(pos.distance)\n elif pos.right:\n robot.right(pos.distance)\n\ndef stop():\n robot.stop()\n\nbd.when_pressed = move\nbd.when_moved = move\nbd.when_released = stop\n\npause()\n"
},
{
"path": "docs/examples/robot3.py",
"content": "from gpiozero import Robot\nfrom bluedot import BlueDot\nfrom signal import pause\n\ndef pos_to_values(x, y):\n left = y if x > 0 else y + x\n right = y if x < 0 else y - x\n return (clamped(left), clamped(right))\n\ndef clamped(v):\n return max(-1, min(1, v))\n\ndef drive():\n while True:\n if bd.is_pressed:\n x, y = bd.position.x, bd.position.y\n yield pos_to_values(x, y)\n else:\n yield (0, 0)\n\nrobot = Robot(left=(lfpin, lbpin), right=(rfpin, rbpin))\nbd = BlueDot()\n\nrobot.source = drive()\n\npause()\n"
},
{
"path": "docs/examples/rotation.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ncount = 0\n\ndef rotated(rotation):\n global count\n count += rotation.value\n\n print(\"{} {} {}\".format(count,\n rotation.clockwise,\n rotation.anti_clockwise))\n\nbd = BlueDot()\nbd.when_rotated = rotated\n\npause()\n"
},
{
"path": "docs/examples/shout_hello.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef shout_hello():\n print(\"HELLO\")\n\nbd = BlueDot()\nbd.when_double_pressed = shout_hello\n\npause()\n"
},
{
"path": "docs/examples/slider_centre.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef show_percentage(pos):\n percentage = round(pos.distance * 100, 2)\n print(\"{}%\".format(percentage))\n\nbd = BlueDot()\nbd.when_moved = show_percentage\n\npause()\n"
},
{
"path": "docs/examples/slider_dimmer.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import PWMLED\nfrom signal import pause\n\ndef set_brightness(pos):\n brightness = (pos.y + 1) / 2\n led.value = brightness\n\nled = PWMLED(27)\nbd = BlueDot()\nbd.when_moved = set_brightness\n\npause()\n"
},
{
"path": "docs/examples/slider_left_right.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef show_percentage(pos):\n horizontal = ((pos.x + 1) / 2)\n percentage = round(horizontal * 100, 2)\n print(\"{}%\".format(percentage))\n\nbd = BlueDot()\nbd.when_moved = show_percentage\n\npause()\n"
},
{
"path": "docs/examples/swipe1.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\nbd.wait_for_swipe()\nprint(\"Blue Dot swiped\")\n"
},
{
"path": "docs/examples/swipe2.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef swiped():\n print(\"Blue Dot swiped\")\n\nbd = BlueDot()\nbd.when_swiped = swiped\n\npause()\n"
},
{
"path": "docs/examples/swipe_direction.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef swiped(swipe):\n if swipe.up:\n print(\"up\")\n elif swipe.down:\n print(\"down\")\n elif swipe.left:\n print(\"left\")\n elif swipe.right:\n print(\"right\")\n\nbd = BlueDot()\nbd.when_swiped = swiped\n\npause()\n"
},
{
"path": "docs/examples/swipe_speed_angle.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef swiped(swipe):\n print(\"Swiped\")\n print(\"speed={}\".format(swipe.speed))\n print(\"angle={}\".format(swipe.angle))\n print(\"distance={}\".format(swipe.distance))\n\nbd = BlueDot()\nbd.when_swiped = swiped\n\npause()\n"
},
{
"path": "docs/examples/two_buttons.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=2)\r\nbd.when_pressed = pressed\r\n\r\npause()"
},
{
"path": "docs/examples/two_buttons_gap.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=3, rows=1)\r\nbd[1,0].visible = False\r\nbd.when_pressed = pressed\r\n\r\npause()"
},
{
"path": "docs/examples/two_buttons_two_events.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed_1(pos):\r\n print(\"button 1 pressed\")\r\n\r\ndef pressed_2(pos):\r\n print(\"button 2 pressed\")\r\n\r\nbd = BlueDot(cols=2, rows=1)\r\n\r\nbd[0,0].when_pressed = pressed_1\r\nbd[1,0].when_pressed = pressed_2\r\n\r\npause()"
},
{
"path": "docs/gettingstarted.rst",
"content": "Getting Started\n===============\n\nIn order to use Blue Dot you will need:\n\n* A Raspberry Pi\n\n - with built-in Bluetooth (such as the Raspberry Pi 3, 4 or Zero W)\n - or a USB Bluetooth dongle\n\n* An Android phone or 2nd Raspberry Pi for the remote\n* An Internet connection (for the install)\n\nInstallation\n------------\n\nThese instructions assume your Raspberry Pi is running the latest version of\n`Raspbian`_.\n\nAndroid App\n~~~~~~~~~~~\n\nIf you're using an Android phone, the `Blue Dot app`_ can be installed from the\nGoogle Play Store.\n\nPython Library\n~~~~~~~~~~~~~~\n\nOpen a terminal (click :menuselection:`Menu --> Accessories --> Terminal`),\nthen enter::\n\n sudo pip3 install bluedot\n\nTo upgrade to the latest version::\n\n sudo pip3 install bluedot --upgrade\n\nPairing\n-------\n\nIn order to use Blue Dot you will need to pair the Raspberry Pi to the remote\n:doc:`Android phone ` or :doc:`2nd Raspberry Pi `.\n\nCode\n----\n\n1. Start up Python 3 (e.g. :menuselection:`Menu --> Programming --> Thonny Python\n IDE`)\n\n2. Create a new program\n\n3. Enter the following code::\n\n from bluedot import BlueDot\n bd = BlueDot()\n bd.wait_for_press()\n print(\"You pressed the blue dot!\")\n\n4. Save your program as :file:`mydot.py`\n\n5. Run the program::\n\n Server started ##:##:##:##:##:##\n Waiting for connection\n\n.. warning::\n\n Do not save your program as :file:`bluedot.py` as Python will try and\n import your program rather than the bluedot module and you will get the\n error ``ImportError: cannot import name BlueDot``.\n\nConnecting\n----------\n\nStart-up the `Blue Dot app`_ on your Android phone or run the\n:doc:`bluedotpythonapp` on your 2nd Raspberry Pi:\n\n1. Select your Raspberry Pi from the list\n\n.. note::\n\n Your python program will need to be running and ``Waiting for connection`` \n before the BlueDot app will be able to connect to your Raspberry Pi.\n\n2. Press the Blue Dot\n\nWhere next\n----------\n\nCheck out the :doc:`recipes` and the :doc:`dotapi` documentation for more ideas\non using Blue Dot.\n\n.. _Blue Dot app: http://play.google.com/store/apps/details?id=com.stuffaboutcode.bluedot\n.. _Raspbian: https://www.raspberrypi.org/downloads/raspbian/\n"
},
{
"path": "docs/index.rst",
"content": ".. include:: ../README.rst\n\nTable of Contents\n=================\n\n.. toctree::\n :maxdepth: 2\n\n gettingstarted\n pairpiandroid\n pairpipi\n recipes\n bluedotandroidapp\n bluedotpythonapp\n dotapi\n btcommapi\n mockapi\n protocol\n build\n changelog\n"
},
{
"path": "docs/mockapi.rst",
"content": "Mock API\n========\nBlue Dot also contains a useful :mod:`mock` API for simulating Blue Dot and\nbluetooth comms. This is useful for testing and allows for prototyping\nwithout having to use a Blue Dot client.\n\n.. module:: bluedot.mock\n\nMockBlueDot\n-----------\n\n.. autoclass:: MockBlueDot\n\nMockBluetoothServer\n-------------------\n\n.. autoclass:: MockBluetoothServer\n\nMockBluetoothClient\n-------------------\n\n.. autoclass:: MockBluetoothClient\n"
},
{
"path": "docs/pairpiandroid.rst",
"content": "Pair a Raspberry Pi and Android phone\n=====================================\n\nUsing the Desktop\n-----------------\n\nOn your Android phone:\n\n1. Open Settings\n\n2. Select Bluetooth and make your phone \"discoverable\"\n\nOn your Raspberry Pi:\n\n1. Click :menuselection:`Bluetooth --> Turn On Bluetooth` (if it's off)\n\n2. Click :menuselection:`Bluetooth --> Make Discoverable`\n\n3. Click :menuselection:`Bluetooth --> Add Device`\n\n4. Your phone will appear in the list, select it and click :guilabel:`Pair`\n\nOn your Android phone and Raspberry Pi.\n\n1. Confirm the pairing code matches\n\n2. Click OK\n\n.. note::\n\n You may receive errors relating to services not being able available or being unable to connect: these can be ignored, your phone and Raspberry Pi are now paired.\n\nUsing the Command Line\n----------------------\n\nOn your Android phone:\n\n1. Open Settings\n\n2. Select Bluetooth and make your phone \"discoverable\"\n\nOn your Raspberry Pi:\n\n1. Type :command:`bluetoothctl` and press Enter to open Bluetooth control\n\n2. At the ``[bluetooth]#`` prompt enter the following commands::\n\n discoverable on\n pairable on\n agent on\n default-agent\n scan on\n\n3. Wait for a message to appear showing the Android phone has been found::\n\n [NEW] Device 12:23:34:45:56:67 devicename\n\n4. Type pair with the mac address of your Android phone::\n\n pair 12:23:34:45:56:67\n\nOn your Android phone and Raspberry Pi.\n\n1. Confirm the passcode.\n\n2. Type :command:`quit` and press Enter to return to the command line"
},
{
"path": "docs/pairpipi.rst",
"content": "Pair 2 Raspberry Pis\n====================\n\nThe instructions below describe pairing a couple of Raspberry Pis which either\nhave built-in Bluetooth (the Pi 3B or the Pi Zero W) or a USB Bluetooth dongle.\n\nUsing the Desktop\n-----------------\n\nOn the first Raspberry Pi:\n\n1. Click :menuselection:`Bluetooth --> Turn On Bluetooth` (if it's off)\n\n2. Click :menuselection:`Bluetooth --> Make Discoverable`\n\nOn the second Raspberry Pi:\n\n1. Click :menuselection:`Bluetooth --> Turn On Bluetooth` (if it's off)\n\n2. Click :menuselection:`Bluetooth --> Make Discoverable`\n\n3. Click :menuselection:`Bluetooth --> Add Device`\n\n4. The first Pi will appear in the list: select it and click the :guilabel:`Pair` button\n\nOn the first Raspberry Pi again:\n\n1. Accept the pairing request\n\n.. note::\n\n You may receive errors relating to services not being able available or being unable to connect: these can be ignored.\n\nUsing the Command Line\n----------------------\n\nOn the first Raspberry Pi:\n\n1. Enter :command:`bluetoothctl` to open Bluetooth control\n\n2. At the ``[bluetooth]#`` prompt enter the following commands::\n\n discoverable on\n pairable on\n agent on\n default-agent\n\nOn the second Raspberry Pi:\n\n1. Enter :command:`bluetoothctl` to open Bluetooth control\n\n2. At the ``[bluetooth]#`` prompt enter the following commands::\n\n discoverable on\n pairable on\n agent on\n default-agent\n scan on\n\n3. Wait for a message to appear showing the first Pi has been found::\n\n [NEW] Device 12:23:34:45:56:67 devicename\n\n4. Type pair with the mac address of the first Pi::\n\n pair 12:23:34:45:56:67\n\nOn both Raspberry Pi's:\n\n1. Confirm the passcode.\n\n2. Type :command:`quit` and press Enter to return to the command line\n"
},
{
"path": "docs/protocol.rst",
"content": "Protocol\n========\n\nBlue Dot uses a client/server model. The :class:`BlueDot` class starts a\nBluetooth server, the Blue Dot application connects as a client.\n\nThe detail below can be used to create new applications (clients); if you do\nplease send a pull request :)\n\nBluetooth\n---------\n\nCommunication over Bluetooth is made using a RFCOMM serial port profile using \nUUID \"00001101-0000-1000-8000-00805f9b34fb\".\n\nSpecification\n-------------\n\nThe transmission of data from client to server or server to client is a \nsimple stream no acknowledgements or data is sent in response to commands.\n\nAll messages between conform to the same format::\n\n [operation],[params],[*]\\n\n\nMessages are sent as utf-8 encoded strings.\n\n*\\\\n* represents the new-line character.\n\nThe following operations are used to communicate between client and server.\n\n+-------------------+-------------------------------------------------------------+-----------------+\n| Operations | Message format | Direction |\n+===================+=============================================================+=================+\n| Button released | ``0,[col],[row],[x],[y]\\n`` | Client > Server |\n+-------------------+-------------------------------------------------------------+-----------------+\n| Button pressed | ``1,[col],[row],[x],[y]\\n`` | Client > Server |\n+-------------------+-------------------------------------------------------------+-----------------+\n| Button moved | ``2,[col],[row],[x],[y]\\n`` | Client > Server |\n+-------------------+-------------------------------------------------------------+-----------------+\n| Protocol check | ``3,[protocol version],[client name]\\n`` | Client > Server |\n+-------------------+-------------------------------------------------------------+-----------------+\n| Set config | ``4,[color],[square],[border],[visible],[cols],[rows]\\n`` | Server > Client |\n+-------------------+-------------------------------------------------------------+-----------------+\n| Set button config | ``5,[color],[square],[border],[visible],[col],[row]\\n`` | Server > Client |\n+-------------------+-------------------------------------------------------------+-----------------+\n\nMessages are constructed using the following parameters.\n\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| Parameter | Description |\n+===================+=============================================================================================================+\n| cols | The number of columns in the matrix of buttons |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| rows | The number of rows in the matrix of buttons |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| col | The column position of the button (0 is top) |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| row | The row position of the button (0 is left) |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| x | Horizontal position between -1 and +1, with 0 being the centre and +1 being the right radius of the button. |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| y | Vertical position between -1 and +1, with 0 being the centre and +1 being the top radius of the button. |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| protocol version | The version of protocol the client supports. |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| client name | The name of the client e.g. \"Android Blue Dot App\" |\n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| color | A hex value in the format ``#rrggbbaa`` representing red, green, blue, alpha values. | \n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| square | 0 or 1, 1 if the dot should be a square. | \n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| border | 0 or 1, 1 if the dot should have a border. | \n+-------------------+-------------------------------------------------------------------------------------------------------------+\n| visible | 0 or 1, 1 if the dot should be visible. | \n+-------------------+-------------------------------------------------------------------------------------------------------------+\n\nMessages are sent when:\n\n1. A client connects\n2. When the setup (or appearance) of a button changes\n3. A button is released, pressed or moved\n\n.. image:: images/protocol_state.png\n :alt: Diagram showing the protocol states\n\nExample\n-------\n\nWhen the Android client connects using protocol version 2::\n\n 3,2,Android Blue Dot app\\n\n\nThe setup of the Blue Dot is sent to the client::\n\n 4,#0000ffff,0,0,1,1,2\\n\n\nIf any buttons are different to the default, the configuration is sent::\n\n 5,#00ff0000,0,0,1,0,1\\n\n\nIf the \"first\" button at position [0,0] is pressed at the top, the following message will be sent::\n\n 1,0,0,0.0,1.0\\n\n\nWhile the button is pressed (held down), the user moves their finger to the\nfar right causing the following message to be sent::\n\n 2,0,0,1.0,0.0\\n\n\nThe button is then released, resulting in the following message::\n\n 0,0,0,1.0,0.0\\n\n\nThe color of the button is changed to \"red\" the server sends to the client::\n\n 5,#ff0000ff,0,0,1,0,0\\n\n\nVersions\n--------\n\n* 0 - initial version\n* 1 - introduction of operation 3, 4\n* 2 - Blue Dot version 2, introduction of col, row for multiple buttons and operation 5"
},
{
"path": "docs/recipes.rst",
"content": "Recipes\n=======\n\nThe recipes provide examples of how you can use Blue Dot. Don't be restricted\nby these ideas and be sure to have a look at the :doc:`dotapi` as there is more\nto be discovered.\n\nButton\n------\n\nThe simplest way to use the Blue Dot is as a wireless button.\n\nHello World\n~~~~~~~~~~~\n\n.. currentmodule:: bluedot\n\nLet's say \"Hello World\" by creating the :class:`BlueDot` object then waiting\nfor the Blue Dot app to connect and the button be pressed:\n\n.. literalinclude:: examples/hello_world.py\n\nAlternatively you can also use :attr:`~BlueDot.when_pressed` to call a\nfunction:\n\n.. literalinclude:: examples/hello_event.py\n\n:attr:`~BlueDot.wait_for_release` and :attr:`~BlueDot.when_released` also allow\nyou to interact when the button is released:\n\n.. literalinclude:: examples/goodbye_world.py\n\nDouble presses can also be used with :attr:`~BlueDot.wait_for_double_press` and\n:attr:`~BlueDot.when_double_pressed`:\n\n.. literalinclude:: examples/shout_hello.py\n\nFlash an LED\n~~~~~~~~~~~~\n\nUsing Blue Dot in combination with :mod:`gpiozero` you can interact with\nelectronic components, such as LEDs, connected to your Raspberry Pi.\n\nWhen a button is pressed, the LED connected to GPIO 27 will turn on; when\nreleased it will turn off:\n\n.. literalinclude:: examples/led1.py\n\nYou could also use :attr:`~BlueDot.when_pressed` and\n:attr:`~BlueDot.when_released`:\n\n.. literalinclude:: examples/led2.py\n\nAlternatively use :attr:`~gpiozero.SourceMixin.source` and\n:attr:`~BlueDot.values`:\n\n.. literalinclude:: examples/led3.py\n\nRemote Camera\n~~~~~~~~~~~~~\n\nUsing a Raspberry Pi camera module, :class:`picamera.PiCamera` and\n:class:`BlueDot`, you can really easily create a remote camera:\n\n.. literalinclude:: examples/camera.py\n\nJoystick\n--------\n\nThe Blue Dot can also be used as a joystick when the middle, top, bottom, left\nor right areas of the dot are touched.\n\nD-pad\n~~~~~\n\nUsing the position the Blue Dot was pressed you can work out whether it was\npressed to go up, down, left, right like the `D-pad`_ on a joystick:\n\n.. literalinclude:: examples/dpad.py\n\nAt the moment the `D-pad`_ only registers when it is pressed. To get it work\nwhen the position is moved you should add the following line above\n:code:`pause()`::\n\n bd.when_moved = dpad\n\nRobot\n~~~~~\n\nThese recipes assume your robot is constructed with a pair of H-bridges. The\nforward and backward pins for the H-bridge of the left wheel are 17 and 18\nrespectively, and the forward and backward pins for H-bridge of the right wheel\nare 22 and 23 respectively.\n\nUsing the Blue Dot and :class:`gpiozero.Robot`, you can create a `bluetooth\ncontrolled robot`_ which moves when the dot is pressed and stops when it is\nreleased:\n\n.. literalinclude:: examples/robot1.py\n\nVariable Speed Robot\n~~~~~~~~~~~~~~~~~~~~\n\nYou can change the robot to use variable speeds, so the further towards the\nedge you press the Blue Dot, the faster the robot will go.\n\nThe :attr:`~BlueDotPosition.distance` attribute returns how far from the centre\nthe Blue Dot was pressed, which can be passed to the robot's functions to\nchange its speed:\n\n.. literalinclude:: examples/robot2.py\n\nAlternatively you can use a generator and yield (x, y) values to the\n:attr:`gpiozero.Robot.source` property (courtesy of `Ben Nuttall`_):\n\n.. literalinclude:: examples/robot3.py\n\nAppearance\n----------\n\nThe button doesn't have to be blue or a dot, you can change how it looks, or make it completely invisible.\n\n.. image:: images/bluedot_color_changing_smaller.gif\n :alt: Animation of blue dot app cycling through colors and changing to a square\n\nColo(u)r\n~~~~~~~~\n\nTo change the color of the button use the :attr:`~BlueDot.color`: property:\n\n.. literalinclude:: examples/looks_color.py\n\nA dictionary of available colors can be obtained from ``bluedot.COLORS``.\n\nThe color can also be set using a hex value of `#rrggbb` or `#rrggbbaa` value::\n\n bd.color = \"#00ff00\"\n\nOr a tuple of 3 or 4 integers between `0` and `255` either (red, gree, blue) or (red, green, blue, alpha)::\n\n bd.color = (0, 255, 0)\n\nSquare\n~~~~~~\n\nThe button can also be made square using the :attr:`~BlueDot.square`: property:\n\n.. literalinclude:: examples/looks_square.py\n\nBorder\n~~~~~~\n\nA border can also been added to the button by setting the :attr:`~BlueDot.border`: property to `True`:\n\n.. literalinclude:: examples/looks_border.py\n\n(In)visible\n~~~~~~~~~~~\n\nThe button can be hidden and shown using the :attr:`~BlueDot.visible`: property:\n\n.. literalinclude:: examples/looks_visible.py\n\nLayout\n-------\n\nYou can have as many buttons as you want.\n\nThe Buttons need to be in a grid of columns and rows.\n\n.. image:: images/layout_many_buttons_small.png\n :alt: Android blue dot app showing 10 buttons in a 2x5 grid\n\nBy hiding specific buttons and being creative with the button's appearance you can create very sophisticated layouts for your controllers using Blue Dot.\n\n.. image:: images/layout_joypad_small.png\n :alt: Android blue dot app showing buttons layed out like a classic joypad\n\nThe Blue Dot android app supports multi touch allowing you to use multiple buttons simultaneously\n\n.. note::\n\n Currently only the Android client app supports multi buttons.\n\nTwo Buttons\n~~~~~~~~~~~\n\nCreate 2 buttons side by side, by setting the number of `cols` to `2`:\n\n.. image:: images/layout_2_buttons_small.png\n :alt: Android blue dot app showing 2 buttons side by side\n\n.. literalinclude:: examples/two_buttons.py\n\nThe buttons could be made verticle by setting the `rows` attribute::\n\n bd = BlueDot(rows=2)\n\nEach button can be set to call its own function by using the grid position:\n\n.. literalinclude:: examples/two_buttons_two_events.py\n\nTo create a gap in between the buttons you could create a row of 3 buttons and hide the middle button:\n\n.. image:: images/layout_2_buttons_gap_small.png\n :alt: Android blue dot app showing 2 buttons side by side with a gap in the middle\n\n.. literalinclude:: examples/two_buttons_gap.py\n\nMany Buttons\n~~~~~~~~~~~~\n\nCreate a grid of buttons by setting the `cols` and `rows` e.g. 10 buttons in a 2x5 grid:\n\n.. image:: images/layout_many_buttons_small.png\n :alt: Android blue dot app showing 10 buttons in a 2x5 grid\n\n.. literalinclude:: examples/many_buttons.py\n\nYou could assign all the buttons random colors:\n\n.. literalinclude:: examples/many_buttons_random_colors.py\n\nD-pad\n~~~~~\n\nCreate a traditional d-pad layout by using a 3x3 grid and hide the buttons at the corners and in the middle:\n\n.. image:: images/layout_dpad_small.png\n :alt: Android blue dot app showing 4 buttons arranged in a cross\n\n.. literalinclude:: examples/dpad_layout.py\n\nAdd 2 buttons on the right to create a joypad:\n\n.. image:: images/layout_joypad_small.png\n :alt: Android blue dot app showing buttons layed out like a classic joypad\n\n.. literalinclude:: examples/dpad_layout.py\n\nSlider\n------\n\nBy holding down a button and moving the position you can use it as an\nanalogue slider.\n\nCentre Out\n~~~~~~~~~~\n\nUsing the :attr:`BlueDotPosition.distance` property which is returned when the\nposition is moved you can create a slider which goes from the centre out in any\ndirection:\n\n.. literalinclude:: examples/slider_centre.py\n\nLeft to Right\n~~~~~~~~~~~~~\n\nThe :attr:`BlueDotPosition.x` property returns a value from -1 (far left) to 1\n(far right). Using this value you can create a slider which goes horizontally\nthrough the middle:\n\n.. literalinclude:: examples/slider_left_right.py\n\nTo make a vertical slider you could change the code above to use\n:attr:`BlueDotPosition.y` instead.\n\nDimmer Switch\n~~~~~~~~~~~~~\n\nUsing the :class:`gpiozero.PWMLED` class and :class:`BlueDot` as a vertical\nslider you can create a wireless dimmer switch:\n\n.. literalinclude:: examples/slider_dimmer.py\n\nSwiping\n-------\n\nYou can interact with the Blue Dot by swiping across it, like you would to move\nbetween pages in a mobile app.\n\nSingle\n~~~~~~\n\nDetecting a single swipe is easy using :attr:`~BlueDot.wait_for_swipe`:\n\n.. literalinclude:: examples/swipe1.py\n\nAlternatively you can also use :attr:`~BlueDot.when_swiped` to call a\nfunction:\n\n.. literalinclude:: examples/swipe2.py\n\nDirection\n~~~~~~~~~\n\nYou can tell what direction the Blue Dot is swiped by using the\n:class:`BlueDotSwipe` object passed to the function assigned to\n:attr:`~BlueDot.when_swiped`:\n\n.. literalinclude:: examples/swipe_direction.py\n\nSpeed, Angle, and Distance\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n:class:`BlueDotSwipe` returns more than just the direction. It also includes\nthe speed of the swipe (in Blue Dot radius per second), the angle, and the\ndistance between the start and end positions of the swipe:\n\n.. literalinclude:: examples/swipe_speed_angle.py\n\nRotating\n--------\n\nYou can use Blue Dot like a rotary encoder or \"iPod classic click wheel\" -\nrotating around the outer edge of the Blue Dot will cause it to \"tick\". The\nBlue Dot is split into a number of virtual segments (the default is 8), when\nthe position moves from one segment to another, it ticks.\n\nCounter\n~~~~~~~\n\nUsing the :attr:`~BlueDot.when_rotated` callback you can create a counter which\nincrements / decrements when the Blue Dot is rotated either clockwise or\nanti-clockwise. A :class:`BlueDotRotation` object is passed to the callback.\nIts :attr:`~BlueDotRotation.value` property will be -1 if rotated\nanti-clockwise and 1 if rotated clockwise:\n\n.. literalinclude:: examples/rotation.py\n\nThe rotation speed can be modified using the :attr:`BlueDot.rotation_segments`\nproperty which changes the number of segments the Blue Dot is split into::\n\n bd.rotation_segments = 16\n\nMultiple Blue Dot Apps\n----------------------\n\nYou can connect multiple Blue Dot clients (apps) to a single server (python \nprogram) by using different Bluetooth ports for each app.\n\nCreate multiple `BlueDot` servers using specific ports:\n\n.. literalinclude:: examples/multiple_dots.py\n\nChange the BlueDot app to use the specific port by:\n\n1. Opening settings from the menu\n2. Turning *Use default port* off\n3. Selecting the specific *Bluetooth port*\n\n.. image:: images/bluedotandroid_settings.png\n :alt: Android blue dot app showing the settings option on the menu\n\n.. image:: images/bluedotandroid_settings_defaultport.png\n :alt: Android blue dot app showing the settings page and use default port turned on\n\n.. image:: images/bluedotandroid_settings_port.png\n :alt: Android blue dot app showing the settings page, use default port turned off and bluetooth port 1 selected\n\nBluetooth\n---------\n\nYou can interact with the Bluetooth adapter using :class:`BlueDot`.\n\nPairing\n~~~~~~~\n\nYou can put your Raspberry Pi into pairing mode which will allow pairing from\nother devices for 60 seconds:\n\n.. literalinclude:: examples/bt_pairing.py\n\nOr connect up a physical button up to start the pairing (the button is assumed\nto be wired to GPIO 27):\n\n.. literalinclude:: examples/bt_pair_button.py\n\nPaired Devices\n~~~~~~~~~~~~~~\n\nYou can iterate over the devices that your Raspberry Pi is paired too:\n\n.. literalinclude:: examples/bt_enumerate.py\n\nTesting\n-------\n\nBlue Dot includes a :class:`MockBlueDot` class to allow you to test and debug\nyour program without having to use Bluetooth or a Blue Dot client.\n\n:class:`MockBlueDot` inherits from :class:`BlueDot` and is used in the same\nway, but you have the option of launching a mock app which you can click with a\nmouse or writing scripts to simulate the Blue Dot being used.\n\n.. image:: images/mockbluedot.png\n :alt: Screenshot of the mock Blue Dot app\n\nMock App\n~~~~~~~~\n\nLaunch the mock Blue Dot app to test by clicking the on-screen dot with the\nmouse:\n\n.. literalinclude:: examples/mock_app.py\n\nScripted Tests\n~~~~~~~~~~~~~~\n\nTests can also be scripted using :class:`MockBlueDot`:\n\n.. literalinclude:: examples/mock_script.py\n\n\n.. _Ben Nuttall: https://github.com/bennuttall\n.. _bluetooth controlled robot: https://youtu.be/eW9oEPySF58\n.. _D-pad: https://en.wikipedia.org/wiki/D-pad\n"
},
{
"path": "examples/adapter_details.py",
"content": "from bluedot import BlueDot\nbd = BlueDot()\n\nprint(\"Address {}\".format(bd.adapter.address))\nprint(\"powered {}\".format(bd.adapter.powered))\nprint(\"discoverable {}\".format(bd.adapter.discoverable))\nprint(\"pairable {}\".format(bd.adapter.pairable))\n\nprint(\"paired devices:\")\npaired_devices = bd.paired_devices\nfor d in paired_devices:\n print(\" mac {} name {}\".format(d[0], d[1]))\n\n"
},
{
"path": "examples/click_wheel.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ncount = 0\n\ndef rotated(rotation):\n global count\n count += rotation.value\n\n print(\"{} {} {}\".format(count, rotation.clockwise, rotation.anti_clockwise))\n\nbd = BlueDot()\nbd.when_rotated = rotated\n\npause()\n"
},
{
"path": "examples/client_connects.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef client_connected():\r\n print(\"callback - a blue dot client connected\")\r\n\r\ndef client_disconnected():\r\n print(\"callback - the blue dot client disconnected\")\r\n\r\nbd = BlueDot()\r\nbd.when_client_connects = client_connected\r\nbd.when_client_disconnects = client_disconnected\r\n\r\npause()"
},
{
"path": "examples/client_debug.py",
"content": "from bluedot.btcomm import BluetoothClient\nfrom datetime import datetime\nfrom time import sleep\nfrom signal import pause\n\ndef data_received(data):\n print(\"recv - {}\".format(data))\n\nprint(\"Connecting\")\nc = BluetoothClient(\"devpi\", data_received)\n\nprint(\"Sending\")\ntry:\n while True:\n c.send(\"hi {} \\n\".format(str(datetime.now())))\n sleep(1)\nfinally:\n c.disconnect()\n\n"
},
{
"path": "examples/color_changer.py",
"content": "from bluedot import BlueDot\n# color zero can be installed using sudo pip3 install colorzero\nfrom colorzero import Color\nfrom signal import pause\n\ndef on(pos):\n hue = (pos.angle + 180) / 360\n c = Color(h=hue, s=1, v=pos.distance)\n bd.color = c.rgb_bytes\n\ndef off():\n bd.color = \"blue\"\n\nbd = BlueDot()\nbd.when_pressed = on\nbd.when_moved = on\nbd.when_released = off\n\npause()"
},
{
"path": "examples/connect_multiple_apps.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef bd1_pressed():\r\n print(\"BlueDot 1 pressed\")\r\n\r\ndef bd2_pressed():\r\n print(\"BlueDot 2 pressed\")\r\n\r\nbd1 = BlueDot(port = 1)\r\nbd2 = BlueDot(port = 2)\r\n\r\nbd1.when_pressed = bd1_pressed\r\nbd2.when_pressed = bd2_pressed\r\n\r\npause()\r\n"
},
{
"path": "examples/dot_changer.py",
"content": "from bluedot import BlueDot\r\nfrom bluedot.colors import RED, GREEN\r\n\r\nfrom signal import pause\r\n\r\ndef change_dot(pos):\r\n if pos.top:\r\n if bd.color == \"red\":\r\n bd.color = GREEN\r\n else:\r\n bd.color = \"#ff0000\"\r\n elif pos.bottom:\r\n if bd.border:\r\n bd.border = False\r\n else:\r\n bd.border = True\r\n elif pos.left:\r\n if bd.visible:\r\n bd.visible = False\r\n else:\r\n bd.visible = True\r\n elif pos.right:\r\n if bd.square:\r\n bd.square = False\r\n else:\r\n bd.square = True\r\n\r\nbd = BlueDot()\r\nbd.color=\"pink\"\r\nbd.border = False\r\nbd.square = True\r\nbd.when_pressed = change_dot\r\n\r\npause()"
},
{
"path": "examples/dot_debug.py",
"content": "from bluedot import BlueDot\nfrom time import sleep, time\n\ndot = BlueDot(auto_start_server = False)\ndot.resize(1,2)\ndot.allow_pairing()\n\ndef pressed(pos):\n print(\"Pressed: x={} y={} angle={} distance={} middle={} top={} bottom={} left={} right={} time={}\".format(pos.x, pos.y, pos.angle, pos.distance, pos.middle, pos.top, pos.bottom, pos.left, pos.right, time()))\n\ndef pressed_two(pos):\n print(\"Second dot:\" + str(pos))\n\ndef released():\n print(\"Released: x={} y={}\".format(dot.position.x, dot.position.y))\n\ndef moved(pos):\n print(\"Moved: x={} y={}\".format(pos.x, pos.y))\n\ndef swiped(swipe):\n print(\"Swiped: up={} down={} left={} right={} speed={}\".format(swipe.up, swipe.down, swipe.left, swipe.right, swipe.speed))\n\ndef double_presed(pos):\n print(\"Double pressed: x={} y={}\".format(pos.x, pos.y))\n\ndef client_connected():\n print(\"connected callback\")\n\ndef client_disconnected():\n print(\"disconnected callback\")\n\ndef rotated(rotation):\n print(\"rotated: direction={}\".format(rotation.value))\n\ndot.when_client_connects = client_connected\ndot.when_client_disconnects = client_disconnected\ndot.when_pressed = pressed\ndot.when_released = released\ndot.when_moved = moved\ndot.when_swiped = swiped\ndot.when_double_pressed = double_presed\ndot.when_rotated = rotated\ndot[0,1].when_pressed = pressed_two\n\ndot.start()\n\ndot.wait_for_press()\nprint(\"wait for press\")\ndot.wait_for_move()\nprint(\"wait for move\")\ndot.wait_for_release()\nprint(\"wait for release\")\ndot.wait_for_double_press()\nprint(\"wait for double press\")\ndot.wait_for_swipe()\nprint(\"wait for swipe\")\n\ntry:\n while True:\n sleep(0.1)\nfinally:\n dot.stop()\n"
},
{
"path": "examples/dot_single_button_debug.py",
"content": "from bluedot import BlueDot\r\nfrom time import sleep, time\r\n\r\ndot = BlueDot(auto_start_server = False)\r\ndot.allow_pairing()\r\n\r\ndef pressed(pos):\r\n print(\"Pressed: x={} y={} angle={} distance={} middle={} top={} bottom={} left={} right={} time={}\".format(pos.x, pos.y, pos.angle, pos.distance, pos.middle, pos.top, pos.bottom, pos.left, pos.right, time()))\r\n\r\ndef released():\r\n print(\"Released: x={} y={}\".format(dot.position.x, dot.position.y))\r\n\r\ndef moved(pos):\r\n print(\"Moved: x={} y={}\".format(pos.x, pos.y))\r\n\r\ndef swiped(swipe):\r\n print(\"Swiped: up={} down={} left={} right={} speed={}\".format(swipe.up, swipe.down, swipe.left, swipe.right, swipe.speed))\r\n\r\ndef double_presed(pos):\r\n print(\"Double pressed: x={} y={}\".format(pos.x, pos.y))\r\n\r\ndef client_connected():\r\n print(\"connected callback\")\r\n\r\ndef client_disconnected():\r\n print(\"disconnected callback\")\r\n\r\ndot.when_client_connects = client_connected\r\ndot.when_client_disconnects = client_disconnected\r\ndot.when_pressed = pressed\r\ndot.when_released = released\r\ndot.when_moved = moved\r\ndot.when_swiped = swiped\r\ndot.when_double_pressed = double_presed\r\n\r\ndot.start()\r\n\r\ndot.wait_for_press()\r\nprint(\"wait for press\")\r\ndot.wait_for_move()\r\nprint(\"wait for move\")\r\ndot.wait_for_release()\r\nprint(\"wait for release\")\r\ndot.wait_for_double_press()\r\nprint(\"wait for double press\")\r\ndot.wait_for_swipe()\r\nprint(\"wait for swipe\")\r\n\r\ntry:\r\n while True:\r\n sleep(0.1)\r\nfinally:\r\n dot.stop()\r\n"
},
{
"path": "examples/double_press.py",
"content": "from signal import pause\r\nfrom bluedot import BlueDot\r\nbd = BlueDot()\r\n\r\ndef double_pressed():\r\n print(\"double pressed\")\r\n\r\nbd.when_double_pressed = double_pressed\r\n\r\npause()"
},
{
"path": "examples/dpad.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef dpad(pos):\n if pos.top:\n print(\"up\")\n elif pos.bottom:\n print(\"down\")\n elif pos.left:\n print(\"left\")\n elif pos.right:\n print(\"right\")\n\nbd = BlueDot()\nbd.when_pressed = dpad\nbd.when_moved = dpad\n\npause()\n"
},
{
"path": "examples/dpad_layout.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef up():\r\n print(\"up\")\r\n\r\ndef down():\r\n print(\"down\")\r\n\r\ndef left():\r\n print(\"left\")\r\n\r\ndef right():\r\n print(\"right\")\r\n\r\nbd = BlueDot(cols=3, rows=3)\r\nbd.color = \"gray\"\r\nbd.square = True\r\n\r\nbd[0,0].visible = False\r\nbd[2,0].visible = False\r\nbd[0,2].visible = False\r\nbd[2,2].visible = False\r\nbd[1,1].visible = False\r\n\r\nbd[1,0].when_pressed = up\r\nbd[1,2].when_pressed = down\r\nbd[0,1].when_pressed = left\r\nbd[2,1].when_pressed = right\r\n\r\npause()"
},
{
"path": "examples/hello_world.py",
"content": "from bluedot import BlueDot\n\ndot = BlueDot()\ndot.wait_for_press()\nprint(\"You pressed the blue dot - Hello world\")\n"
},
{
"path": "examples/joypad.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef up():\r\n print(\"up\")\r\n\r\ndef down():\r\n print(\"down\")\r\n\r\ndef left():\r\n print(\"left\")\r\n\r\ndef right():\r\n print(\"right\")\r\n\r\ndef button_A():\r\n print(\"A\")\r\n\r\ndef button_B():\r\n print(\"B\")\r\n\r\nbd = BlueDot(cols=5, rows=3)\r\n\r\n# dpad buttons\r\nbd.color = \"gray\"\r\nbd.square = True\r\nbd[0,0].visible = False\r\nbd[2,0].visible = False\r\nbd[0,2].visible = False\r\nbd[2,2].visible = False\r\nbd[1,1].visible = False\r\n\r\nbd[1,0].when_pressed = up\r\nbd[1,2].when_pressed = down\r\nbd[0,1].when_pressed = left\r\nbd[2,1].when_pressed = right\r\n\r\n# buttons\r\nbd[3,0].visible = False\r\nbd[4,0].visible = False\r\nbd[3,2].visible = False\r\nbd[4,2].visible = False\r\n\r\nbd[3,1].color = \"blue\"\r\nbd[3,1].square = False\r\nbd[3,1].when_pressed = button_A\r\n\r\nbd[4,1].color = \"red\"\r\nbd[4,1].when_pressed = button_B\r\n\r\npause()"
},
{
"path": "examples/many_buttons.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=2, rows=5)\r\nbd.when_pressed = pressed\r\n\r\npause()"
},
{
"path": "examples/matrix_of_dots.py",
"content": "from bluedot import BlueDot, COLORS\r\nfrom signal import pause\r\nfrom random import choice\r\n\r\nbd = BlueDot()\r\nbd.resize(1,2)\r\n\r\ndef pressed(pos):\r\n print(\"Pressed : {}\".format(pos))\r\n\r\ndef moved(pos):\r\n print(\"Moved : {}\".format(pos))\r\n\r\ndef released(pos):\r\n print(\"Released : {}\".format(pos))\r\n\r\ndef double_press(pos):\r\n print(\"Double press : {}\".format(pos))\r\n\r\ndef swipe(swipe):\r\n print(\"Swipe : {}\".format(swipe))\r\n\r\ndef rotation(rotation):\r\n print(\"Rotation : {}\".format(rotation))\r\n\r\ndef increase_matrix():\r\n bd.resize(bd._cols + 1, bd._rows + 1)\r\n # bd._send_cell_config(2, 2, \"#ff0000ff\", False, False, True)\r\n\r\ndef change_color():\r\n # increase_matrix()\r\n # bd[bd.cols - 1, bd.rows - 1].color = \"green\"\r\n for c in range(bd.cols):\r\n for r in range(bd.rows):\r\n bd[c,r].color = choice(list(COLORS.keys()))\r\n\r\n #print(bd.cells)\r\n\r\nchange_color()\r\n\r\n# bd.when_pressed = increase_matrix\r\n\r\n\r\nbd[0,0].when_pressed = pressed\r\nbd[0,0].when_moved = moved\r\nbd[0,0].when_released = released\r\nbd[0,0].when_double_pressed = double_press\r\nbd[0,0].when_swiped = swipe\r\nbd[0,0].when_rotated = rotation\r\nbd.when_pressed = pressed\r\nbd.when_moved = moved\r\nbd.when_released = released\r\nbd.when_double_pressed = double_press\r\nbd.when_swiped = swipe\r\nbd.when_rotated = rotation\r\n\r\npause()"
},
{
"path": "examples/mock_app_debug.py",
"content": "from bluedot import MockBlueDot\nfrom time import sleep, time\n\nmbd = MockBlueDot(auto_start_server = False)\n\ndef pressed(pos):\n print(\"Pressed: x={} y={} angle={} distance={} middle={} top={} bottom={} left={} right={} time={}\".format(pos.x, pos.y, pos.angle, pos.distance, pos.middle, pos.top, pos.bottom, pos.left, pos.right, time()))\n\ndef released():\n print(\"Released: x={} y={}\".format(mbd.position.x, mbd.position.y))\n print()\n\ndef moved(pos):\n print(\"Moved: x={} y={}\".format(pos.x, pos.y))\n\nmbd.when_pressed = pressed\nmbd.when_released = released\nmbd.when_moved = moved\nmbd.start()\n\n#launch a mock app\nmbd.launch_mock_app()\n\ntry:\n while True:\n sleep(1)\nfinally:\n mbd.mock_client_disconnected()\n mbd.stop()\n"
},
{
"path": "examples/mock_btcomm_debug.py",
"content": "from bluedot.mock import MockBluetoothClient, MockBluetoothServer\n\ndef s_client_connected():\n print(\"s: c connected\")\n \ndef s_data_received(data):\n print(\"s: recv - {}\".format(data))\n \nprint(\"s: creating\")\ns = MockBluetoothServer(\n s_data_received,\n when_client_connects=s_client_connected\n )\n\ndef c_data_received(data):\n print(\"c: recv - {}\".format(data))\n\nprint(\"c: creating\")\nc = MockBluetoothClient(\n s, \n c_data_received\n )\n\nc.send(\"hi\")\ns.send(\"bye\")\n"
},
{
"path": "examples/mock_debug.py",
"content": "from bluedot import MockBlueDot\nfrom time import sleep, time\n\nmbd = MockBlueDot(auto_start_server = False)\n\ndef pressed(pos):\n print(\"Pressed: x={} y={} angle={} distance={} middle={} top={} bottom={} left={} right={} time={}\".format(pos.x, pos.y, pos.angle, pos.distance, pos.middle, pos.top, pos.bottom, pos.left, pos.right, time()))\n\ndef released():\n print(\"Released: x={} y={}\".format(mbd.position.x, mbd.position.y))\n print()\n\ndef moved(pos):\n print(\"Moved: x={} y={}\".format(pos.x, pos.y))\n\nmbd.when_pressed = pressed\nmbd.when_released = released\nmbd.when_moved = moved\nmbd.start()\nmbd.mock_client_connected()\nmbd.wait_for_connection()\n\ntry:\n while True:\n mbd.mock_blue_dot_pressed(1.0,1.0)\n mbd.mock_blue_dot_moved(0.5,1.0)\n mbd.mock_blue_dot_released(0.5,1.0)\n sleep(0.1)\nfinally:\n mbd.mock_client_disconnected()\n mbd.stop()\n"
},
{
"path": "examples/remote_camera.py",
"content": "from bluedot import BlueDot\nfrom picamera import PiCamera\nfrom signal import pause\n\ndot = BlueDot()\ncam = PiCamera()\n\ndef take_picture():\n cam.capture(\"pic.jpg\")\n\ndot.when_pressed = take_picture\npause()\n"
},
{
"path": "examples/server_debug.py",
"content": "from bluedot.btcomm import BluetoothServer\nfrom time import sleep\nfrom signal import pause\n\ndef data_received(data):\n print(\"recv - {}\".format(data))\n server.send(data)\n\ndef client_connected():\n print(\"client connected\")\n\ndef client_disconnected():\n print(\"client disconnected\")\n\nprint(\"init\")\nserver = BluetoothServer(\n data_received,\n auto_start = False,\n when_client_connects = client_connected,\n when_client_disconnects = client_disconnected)\n\nprint(\"starting\")\nserver.start()\nprint(server.server_address)\nprint(\"waiting for connection\")\n\ntry:\n pause()\nexcept KeyboardInterrupt as e:\n print(\"cancelled by user\")\nfinally:\n print(\"stopping\")\n server.stop()\nprint(\"stopped\")\n"
},
{
"path": "examples/simple_robot.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import Robot\nfrom signal import pause\n\nbd = BlueDot()\nrobot = Robot(left=(10, 9), right=(8, 7))\n\ndef move(pos):\n if pos.top:\n robot.forward()\n elif pos.bottom:\n robot.backward()\n elif pos.left:\n robot.left()\n elif pos.right:\n robot.right()\n\ndef stop():\n robot.stop()\n\nbd.when_pressed = move\nbd.when_moved = move\nbd.when_released = stop\n\npause()\n"
},
{
"path": "examples/simple_variable_robot.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import Robot\nfrom signal import pause\n\nbd = BlueDot()\nrobot = Robot(left=(10, 9), right=(8, 7))\n\ndef move(pos):\n if pos.top:\n robot.forward(pos.distance)\n elif pos.bottom:\n robot.backward(pos.distance)\n elif pos.left:\n robot.left(pos.distance)\n elif pos.right:\n robot.right(pos.distance)\n\ndef stop():\n robot.stop()\n\nbd.when_pressed = move\nbd.when_moved = move\nbd.when_released = stop\n\npause()\n"
},
{
"path": "examples/slider_centre.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef show_percentage(pos):\n percentage = round(pos.distance * 100, 2)\n print(\"{}%\".format(percentage))\n\nbd = BlueDot()\nbd.when_moved = show_percentage\n\npause()\n"
},
{
"path": "examples/slider_horizontal.py",
"content": "from bluedot import BlueDot\nfrom signal import pause\n\ndef show_percentage(pos):\n horizontal = ((pos.x + 1) / 2)\n percentage = round(horizontal * 100, 2)\n print(\"{}%\".format(percentage))\n\nbd = BlueDot()\nbd.when_moved = show_percentage\n\npause()\n"
},
{
"path": "examples/slider_led_dimmer.py",
"content": "from bluedot import BlueDot\nfrom gpiozero import PWMLED\nfrom signal import pause\n\ndef set_brightness(pos):\n brightness = ((pos.y + 1) / 2)\n led.value = brightness\n\nbd = BlueDot()\nbd.when_moved = set_brightness\nled = PWMLED(17)\n\npause()\n"
},
{
"path": "examples/source_robot.py",
"content": "from gpiozero import Robot\nfrom bluedot import BlueDot\nfrom signal import pause\n\ndef pos_to_values(x, y):\n left = y if x > 0 else y + x\n right = y if x < 0 else y - x\n return (clamped(left), clamped(right))\n\ndef clamped(v):\n return max(-1, min(1, v))\n\ndef drive():\n while True:\n if bd.is_pressed:\n x, y = bd.position.x, bd.position.y\n yield pos_to_values(x, y)\n else:\n yield (0, 0)\n\nif __name__ == '__main__':\n robot = Robot(left=(10, 9), right=(8, 7))\n bd = BlueDot()\n\n robot.source = drive()\n\n pause()\n"
},
{
"path": "examples/swipe_debug.py",
"content": "from bluedot import BlueDot, BlueDotSwipe\nfrom signal import pause\n\nbd = BlueDot()\n\nprint(\"waiting for swipe\")\nbd.wait_for_swipe()\nprint(\"swiped\")\n\ndef released():\n swipe = BlueDotSwipe(bd.interaction)\n if not swipe.valid:\n print(\"Invalid swipe - speed {}\".format(swipe.speed))\n\ndef valid_swipe(swipe):\n #swipe = BlueDotSwipe(bd.interaction)\n #print(\"valid {} duration {} distance {} angle {}\".format(swipe.valid, swipe.interaction.duration, swipe.distance, swipe.angle))\n #print(\"up {} down {} left {} right {}\".format(swipe.up, swipe.down, swipe.left, swipe.right))\n if swipe.up:\n print(\"UP {}\".format(swipe.speed))\n elif swipe.down:\n print(\"DOWN {}\".format(swipe.speed))\n elif swipe.left:\n print(\"LEFT {}\".format(swipe.speed))\n elif swipe.right:\n print(\"RIGHT {}\".format(swipe.speed))\n\nbd.when_released = released\nbd.when_swiped = valid_swipe\n\npause()\n"
},
{
"path": "examples/threaded_callbacks.py",
"content": "from bluedot import BlueDot\r\nfrom time import sleep\r\nfrom signal import pause\r\nbd = BlueDot()\r\n\r\ndef pressed():\r\n print(\"pressed - waiting\")\r\n sleep(3)\r\n print(\"pressed - complete\")\r\n\r\ndef released():\r\n print(\"released\")\r\n\r\nbd.set_when_pressed(pressed, background=True)\r\nbd.when_released = released\r\n\r\npause()\r\n"
},
{
"path": "examples/two_buttons.py",
"content": "from bluedot import BlueDot\r\nfrom signal import pause\r\n\r\ndef pressed(pos):\r\n print(\"button {}.{} pressed\".format(pos.col, pos.row))\r\n\r\nbd = BlueDot(cols=2)\r\nbd.when_pressed = pressed\r\n\r\npause()"
},
{
"path": "examples/wait_for_events.py",
"content": "from bluedot import BlueDot\nfrom turtle import Turtle\n\nbd = BlueDot()\n\nwhile True:\n bd.wait_for_press()\n print(\"pressed\")\n\n bd.wait_for_move()\n print(\"moved\")\n \n bd.wait_for_release()\n print(\"released\")\n\n bd.wait_for_double_press()\n print(\"double press\")\n \n bd.wait_for_swipe()\n print(\"swipe\")\n \n \n \n"
},
{
"path": "setup.py",
"content": "import sys\nfrom setuptools import setup\n\nif sys.version_info.major == 2:\n raise ValueError('This package does not support Python 2')\nelif sys.version_info.major == 3:\n if sys.version_info.minor < 5:\n raise ValueError('This package requires Python 3.5 or newer')\nelse:\n raise ValueError('Python version not identified')\n\n__project__ = 'bluedot'\n__desc__ = 'A zero boiler plate bluetooth remote'\n__version__ = '2.0.0'\n__author__ = \"Martin O'Hanlon\"\n__author_email__ = 'martin@ohanlonweb.com'\n__license__ = 'MIT'\n__url__ = 'https://github.com/martinohanlon/BlueDot'\n__python_requires__ = '>=3.5'\n# __requires__ = ['dbus-python',]\n__keywords__ = [\n \"raspberry\",\n \"pi\",\n \"raspberry pi\",\n \"bluetooth\",\n \"remote\",\n \"android\",\n]\n__classifiers__ = [\n \"Development Status :: 5 - Production/Stable\",\n \"Intended Audience :: Education\",\n \"Intended Audience :: Developers\",\n \"Topic :: Education\",\n \"Topic :: Communications\",\n \"License :: OSI Approved :: MIT License\",\n \"Programming Language :: Python :: 3\",\n \"Programming Language :: Python :: 3.5\",\n \"Programming Language :: Python :: 3.6\",\n \"Programming Language :: Python :: 3.7\",\n \"Programming Language :: Python :: 3.8\",\n]\n__long_description__ = \"\"\"# Blue Dot\n\n[Blue Dot](http://bluedot.readthedocs.io/en/latest/) allows you to control your Raspberry Pi projects wirelessly - it's a Bluetooth remote and zero boiler plate (super simple to use :) Python library.\n\n## Getting started\n\n1. Install\n\n```\nsudo pip3 install bluedot\n```\n\n2. Get the [Android Blue Dot app](http://play.google.com/store/apps/details?id=com.stuffaboutcode.bluedot) or use the [Python Blue Dot app](http://bluedot.readthedocs.io/en/latest/bluedotpythonapp.html)\n\n3. Pair your Raspberry Pi\n\n4. Write some code\n\n```python\nfrom bluedot import BlueDot\nbd = BlueDot()\nbd.wait_for_press()\nprint(\"You pressed the blue dot!\")\n```\n\n5. Press the Blue Dot\n\nSee the [getting started guide](http://bluedot.readthedocs.io/en/latest/gettingstarted.html) to 'get started'!\n\n## More\n\nBlue Dot is more than just one button. You can create as many buttons as you want and change their appearance to create your own controller.\n\nEvery button is also a joystick. You can tell if a button was pressed in the middle, on the top, bottom, left or right. You can easily create a BlueDot controlled Robot.\n\nWhy be restricted by such vague positions like top and bottom though: you can get the exact (x, y) position or even the angle and distance from centre where the button was pressed.\n\nIts not all about when the button was pressed either - pressed, released or moved they all work.\n\nA button can be any colour, square, given give or hidden!\n\nYou can press it, slide it, swipe it, rotate it - one blue circle can do a lot!\n\n## Even more\n\nThe [online documentation](http://bluedot.readthedocs.io/en/latest/) describes how to use Blue Dot and the Python library including recipes and ideas.\n\n\"\"\"\nif __name__ == '__main__':\n setup(name='bluedot',\n version = __version__,\n description = __desc__,\n long_description=__long_description__,\n long_description_content_type='text/markdown',\n url = __url__,\n author = __author__,\n author_email = __author_email__,\n license= __license__,\n keywords=__keywords__,\n classifiers=__classifiers__,\n packages = [__project__],\n # install_requires = __requires__,\n entry_points={\n 'console_scripts': [\n 'bluedotapp = bluedot.app:main'\n ]},\n )\n"
},
{
"path": "tests/test_blue_dot.py",
"content": "import pytest\nfrom bluedot import MockBlueDot, BlueDotSwipe, BlueDotRotation\nfrom bluedot.exceptions import ButtonDoesNotExist\nfrom time import sleep\nfrom threading import Event, Thread\n\ndef test_default_values():\n mbd = MockBlueDot()\n assert mbd.device == \"hci0\"\n assert mbd.port == 1\n assert mbd.running\n assert mbd.cols == 1\n assert mbd.rows == 1\n\n assert mbd.print_messages\n assert mbd.double_press_time == 0.3\n assert mbd.rotation_segments == 8\n\n assert mbd.when_client_connects == None\n assert mbd.when_client_disconnects == None\n assert mbd.when_pressed == None\n assert mbd.when_double_pressed == None\n assert mbd.when_moved == None\n assert mbd.when_released == None\n assert mbd.when_swiped == None\n\n assert len(mbd.buttons) == 1\n\ndef test_modify_values():\n mbd = MockBlueDot(device = \"hci1\", port = 2, auto_start_server = False, print_messages = False, cols = 3, rows = 2)\n assert mbd.device == \"hci1\"\n assert mbd.port == 2\n assert not mbd.running\n assert mbd.cols == 3\n assert mbd.rows == 2\n\n assert not mbd.print_messages\n mbd.print_messages = True\n assert mbd.print_messages\n\n assert mbd.double_press_time == 0.3\n mbd.double_press_time = 0.4\n assert mbd.double_press_time == 0.4\n\n assert mbd.rotation_segments == 8\n mbd.rotation_segments = 16\n assert mbd.rotation_segments == 16\n\n assert len(mbd.buttons) == 6\n\ndef test_start_stop():\n mbd = MockBlueDot(auto_start_server = False)\n assert not mbd.running\n mbd.start()\n assert mbd.running\n mbd.stop()\n assert not mbd.running\n\ndef test_connect_disconnect():\n mbd = MockBlueDot()\n assert not mbd.is_connected\n mbd.mock_client_connected()\n assert mbd.wait_for_connection(1)\n assert mbd.is_connected\n mbd.mock_client_disconnected()\n assert not mbd.is_connected\n\ndef test_when_connect_disconnect():\n mbd = MockBlueDot()\n\n event_connect = Event()\n mbd.when_client_connects = lambda: event_connect.set()\n\n event_disconnect = Event()\n mbd.when_client_disconnects = lambda: event_disconnect.set()\n\n assert not event_connect.is_set()\n mbd.mock_client_connected()\n assert event_connect.wait(1)\n\n assert not event_disconnect.is_set()\n mbd.mock_client_disconnected()\n assert event_disconnect.wait(1)\n\ndef test_when_connect_disconnect_background():\n mbd = MockBlueDot()\n\n event_connect = Event()\n mbd.set_when_client_connects(lambda: delay_function(event_connect.set, 0.2), background=True)\n \n event_disconnect = Event()\n mbd.set_when_client_disconnects(lambda: delay_function(event_disconnect.set, 0.2), background=True)\n mbd.when_client_disconnects = lambda: event_disconnect.set()\n\n assert not event_connect.is_set()\n mbd.mock_client_connected()\n assert not event_connect.is_set()\n assert event_connect.wait(1)\n\n assert not event_disconnect.is_set()\n mbd.mock_client_disconnected()\n assert not event_disconnect.is_set()\n assert event_disconnect.wait(1)\n\ndef test_resize():\n mbd = MockBlueDot()\n mbd.resize(4,3)\n\n assert mbd.cols == 4\n assert mbd.rows == 3\n assert len(mbd.buttons) == 12\n\ndef test_pressed_moved_released():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def pressed_moved_released(dot, col, row):\n \n #initial value\n assert not mbd.is_pressed\n assert dot.value == 0\n\n #pressed\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert dot.is_pressed\n assert dot.value == 1\n\n #released\n mbd.mock_blue_dot_released(col,row,0,0)\n assert not dot.is_pressed\n assert dot.value == 0\n\n #wait_for_press\n delay_function(lambda: mbd.mock_blue_dot_pressed(col,row,0,0), 0.5)\n assert dot.wait_for_press(1)\n assert not dot.wait_for_release(0)\n\n #wait_for_release\n delay_function(lambda: mbd.mock_blue_dot_released(col,row,0,0), 0.5)\n assert dot.wait_for_release(1)\n assert not dot.wait_for_press(0)\n\n def not_pressed(dot, col, row):\n assert not dot.is_pressed\n assert not dot.value == 1\n\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert not dot.is_pressed\n assert not dot.value == 1\n\n # single button\n pressed_moved_released(mbd, 0, 0)\n pressed_moved_released(mbd[0,0], 0, 0)\n\n # resize to 2 buttons\n mbd.resize(2, 1)\n\n # test second button and main\n pressed_moved_released(mbd, 1, 0)\n pressed_moved_released(mbd[1,0], 1, 0)\n\n # test second button isn't pressed by first\n not_pressed(mbd[1,0], 0, 0)\n\ndef test_double_press():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def simulate_double_press(col, row):\n #sleep longer than the double press time, to clear any past double presses!\n sleep(mbd.double_press_time + 0.1)\n mbd.mock_blue_dot_pressed(col,row,0,0)\n mbd.mock_blue_dot_released(col,row,0,0)\n mbd.mock_blue_dot_pressed(col,row,0,0)\n mbd.mock_blue_dot_released(col,row,0,0)\n\n def simulate_failed_double_press(col, row):\n sleep(mbd.double_press_time + 0.1)\n mbd.mock_blue_dot_pressed(col,row,0,0)\n mbd.mock_blue_dot_released(col,row,0,0)\n sleep(mbd.double_press_time + 0.1)\n mbd.mock_blue_dot_pressed(col,row,0,0)\n mbd.mock_blue_dot_released(col,row,0,0)\n\n def double_press(dot, col, row):\n # when_double_pressed\n event_double_pressed = Event()\n dot.when_double_pressed = lambda: event_double_pressed.set()\n\n simulate_failed_double_press(col, row)\n assert not event_double_pressed.is_set()\n\n simulate_double_press(col, row)\n assert event_double_pressed.is_set()\n\n # wait for double press\n # double press the blue dot\n delay_function(lambda: simulate_double_press(col, row), 0.2)\n\n # wait for double press\n assert dot.wait_for_double_press(1)\n\n # dont double press the blue dot\n delay_function(lambda: simulate_failed_double_press(col, row), 0.2)\n assert not dot.wait_for_double_press(1)\n\n def not_double_press(dot, col, row):\n # when_double_pressed\n event_double_pressed = Event()\n dot.when_double_pressed = lambda: event_double_pressed.set()\n\n simulate_double_press(col, row)\n assert not event_double_pressed.is_set()\n\n # single button\n double_press(mbd, 0, 0)\n double_press(mbd[0,0], 0, 0)\n\n mbd.resize(2, 1)\n\n # two buttons\n double_press(mbd, 1, 0)\n double_press(mbd[1,0], 1, 0)\n\n # first button doesnt double press second button\n not_double_press(mbd[1,0], 0, 0)\n\n\ndef test_when_pressed_moved_released():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def when_pressed_moved_released(dot, col, row):\n #when_pressed\n event_pressed = Event()\n dot.when_pressed = lambda: event_pressed.set()\n\n #when_double_pressed\n event_double_pressed = Event()\n dot.when_double_pressed = lambda: event_double_pressed.set()\n\n #when_moved\n event_moved = Event()\n dot.when_moved = lambda: event_moved.set()\n\n #when_released\n event_released = Event()\n dot.when_released = lambda: event_released.set()\n\n assert not event_pressed.is_set()\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert event_pressed.is_set()\n\n assert not event_moved.is_set()\n mbd.mock_blue_dot_moved(col,row,1,1)\n assert event_moved.is_set()\n\n assert not event_released.is_set()\n mbd.mock_blue_dot_released(col,row,0,0)\n assert event_released.is_set()\n\n assert not event_double_pressed.is_set()\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert event_double_pressed.is_set()\n\n when_pressed_moved_released(mbd, 0, 0)\n when_pressed_moved_released(mbd[0,0], 0, 0)\n\n mbd.resize(2,1)\n\n when_pressed_moved_released(mbd, 1, 0)\n when_pressed_moved_released(mbd[1,0], 1, 0)\n\ndef test_when_pressed_moved_released_background():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def when_pressed_moved_released_background(dot, col, row):\n\n #when_pressed\n event_pressed = Event()\n dot.set_when_pressed(lambda: delay_function(event_pressed.set, 0.2), background=True)\n\n #when_double_pressed\n event_double_pressed = Event()\n dot.set_when_double_pressed(lambda: delay_function(event_double_pressed.set, 0.2), background=True)\n \n #when_moved\n event_moved = Event()\n dot.set_when_moved(lambda: delay_function(event_moved.set, 0.2), background=True)\n\n #when_released\n event_released = Event()\n dot.set_when_released(lambda: delay_function(event_released.set, 0.2), background=True)\n \n # test that the events dont block\n assert not event_pressed.is_set()\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert not event_pressed.is_set()\n assert event_pressed.wait(1)\n\n assert not event_moved.is_set()\n mbd.mock_blue_dot_moved(col,row,1,1)\n assert not event_moved.is_set()\n assert event_moved.wait(1)\n\n assert not event_released.is_set()\n mbd.mock_blue_dot_released(col,row,0,0)\n assert not event_released.is_set()\n assert event_released.wait(1)\n\n # set pressed, moved, released to None so they dont wait\n mbd.set_when_pressed(None)\n mbd.set_when_moved(None)\n mbd.set_when_released(None)\n mbd.mock_blue_dot_pressed(col,row,0,0)\n mbd.mock_blue_dot_moved(col,row,1,1)\n mbd.mock_blue_dot_released(col,row,0,0)\n assert not event_double_pressed.is_set()\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert not event_double_pressed.is_set()\n assert event_double_pressed.wait(1)\n\n when_pressed_moved_released_background(mbd, 0, 0)\n when_pressed_moved_released_background(mbd[0,0], 0, 0)\n\n mbd.resize(2,1)\n\n when_pressed_moved_released_background(mbd, 1, 0)\n when_pressed_moved_released_background(mbd[1,0], 1, 0)\n\ndef test_position():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def position(dot, col, row):\n mbd.mock_blue_dot_pressed(col,row,0,0)\n assert not mbd.position.top\n assert mbd.position.middle\n assert not mbd.position.bottom\n assert not mbd.position.left\n assert not mbd.position.right\n\n mbd.mock_blue_dot_moved(col,row,1,0)\n assert not mbd.position.top\n assert not mbd.position.middle\n assert not mbd.position.bottom\n assert not mbd.position.left\n assert mbd.position.right\n\n mbd.mock_blue_dot_moved(col,row,-1,0)\n assert not mbd.position.top\n assert not mbd.position.middle\n assert not mbd.position.bottom\n assert mbd.position.left\n assert not mbd.position.right\n\n mbd.mock_blue_dot_moved(col,row,0,1)\n assert mbd.position.top\n assert not mbd.position.middle\n assert not mbd.position.bottom\n assert not mbd.position.left\n assert not mbd.position.right\n\n mbd.mock_blue_dot_moved(col,row,0,-1)\n assert not mbd.position.top\n assert not mbd.position.middle\n assert mbd.position.bottom\n assert not mbd.position.left\n assert not mbd.position.right\n\n mbd.mock_blue_dot_moved(col,row,0.1234, -0.4567)\n assert mbd.position.x == 0.1234\n assert mbd.position.y == -0.4567\n\n mbd.mock_blue_dot_moved(col,row,1, 0)\n assert mbd.position.distance == 1\n assert mbd.position.angle == 90\n\n position(mbd, 0, 0)\n position(mbd[0,0], 0, 0)\n mbd.resize(2,1)\n position(mbd[1,0], 1, 0)\n\ndef test_interaction():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n \n def interaction(dot, col, row):\n assert dot.interaction == None\n\n mbd.mock_blue_dot_pressed(col,row,-1,0)\n assert dot.interaction.active\n assert len(dot.interaction.positions) == 1\n assert dot.interaction.distance == 0\n assert dot.interaction.pressed_position.x == -1\n assert dot.interaction.pressed_position.y == 0\n assert dot.interaction.current_position.x == -1\n assert dot.interaction.current_position.y == 0\n assert dot.interaction.previous_position == None\n assert dot.interaction.released_position == None\n\n mbd.mock_blue_dot_moved(col,row,0,0)\n assert dot.interaction.active\n assert len(dot.interaction.positions) == 2\n assert dot.interaction.distance == 1\n assert dot.interaction.pressed_position.x == -1\n assert dot.interaction.pressed_position.y == 0\n assert dot.interaction.current_position.x == 0\n assert dot.interaction.current_position.y == 0\n assert dot.interaction.previous_position.x == -1\n assert dot.interaction.previous_position.y == 0\n assert dot.interaction.released_position == None\n\n mbd.mock_blue_dot_released(col,row,1,0)\n assert not dot.interaction.active\n assert len(dot.interaction.positions) == 3\n assert dot.interaction.distance == 2\n assert dot.interaction.pressed_position.x == -1\n assert dot.interaction.pressed_position.y == 0\n assert dot.interaction.current_position.x == 1\n assert dot.interaction.current_position.y == 0\n assert dot.interaction.previous_position.x == 0\n assert dot.interaction.previous_position.y == 0\n assert dot.interaction.released_position.x == 1\n assert dot.interaction.released_position.y == 0\n\n interaction(mbd[0,0], 0, 0)\n\n mbd.resize(2,1)\n \n interaction(mbd[1,0], 1, 0)\n\ndef test_swipe():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def swipe(dot, col, row):\n \n def simulate_swipe(\n col, row,\n pressed_x, pressed_y, \n moved_x, moved_y, \n released_x, released_y):\n\n mbd.mock_blue_dot_pressed(col,row,pressed_x, pressed_y)\n mbd.mock_blue_dot_moved(col,row,moved_x, moved_y)\n mbd.mock_blue_dot_released(col,row,released_x, released_y)\n\n #wait_for_swipe\n delay_function(lambda: simulate_swipe(col,row,-1,0,0,0,1,0), 0.5)\n assert dot.wait_for_swipe(1)\n\n #when_swiped\n event_swiped = Event()\n dot.when_swiped = lambda: event_swiped.set()\n assert not event_swiped.is_set()\n\n #simulate swipe left to right\n simulate_swipe(col,row,-1,0,0,0,1,0)\n #check event\n assert event_swiped.is_set()\n #get the swipe\n swipe = BlueDotSwipe(mbd[col, row].interaction)\n assert swipe.right\n assert not swipe.left\n assert not swipe.up\n assert not swipe.down\n\n #right to left\n event_swiped.clear()\n simulate_swipe(col,row,1,0,0,0,-1,0)\n assert event_swiped.is_set()\n swipe = BlueDotSwipe(mbd[col, row].interaction)\n assert not swipe.right\n assert swipe.left\n assert not swipe.up\n assert not swipe.down\n\n #bottom to top\n event_swiped.clear()\n simulate_swipe(col,row,0,-1,0,0,0,1)\n assert event_swiped.is_set()\n swipe = BlueDotSwipe(mbd[col, row].interaction)\n assert not swipe.right\n assert not swipe.left\n assert swipe.up\n assert not swipe.down\n\n #top to bottom\n event_swiped.clear()\n simulate_swipe(col,row,0,1,0,0,0,-1)\n assert event_swiped.is_set()\n swipe = BlueDotSwipe(mbd[col, row].interaction)\n assert not swipe.right\n assert not swipe.left\n assert not swipe.up\n assert swipe.down\n\n # background\n event_swiped.clear()\n dot.set_when_swiped(lambda: delay_function(event_swiped.set, 0.2), background=True)\n simulate_swipe(col,row,0,1,0,0,0,-1)\n assert not event_swiped.is_set()\n assert event_swiped.wait(1)\n\n swipe(mbd, 0, 0)\n swipe(mbd[0,0], 0, 0)\n\n mbd.resize(2,1)\n\n swipe(mbd, 1, 0)\n swipe(mbd[1,0], 1, 0)\n\n\ndef test_callback_in_class():\n\n class CallbackClass():\n def __init__(self):\n self.event = Event()\n\n def no_pos(self):\n self.event.set()\n self.pos = None\n\n def with_pos(self, pos):\n self.event.set()\n self.pos = pos\n\n cc = CallbackClass()\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n mbd.when_pressed = cc.no_pos\n mbd.mock_blue_dot_pressed(0,0,0,0)\n assert cc.event.is_set()\n assert cc.pos is None\n \n mbd.mock_blue_dot_released(0,0,0,0)\n cc.event.clear()\n\n mbd.when_pressed = cc.with_pos\n mbd.mock_blue_dot_pressed(0,0,0,0)\n assert cc.event.is_set()\n assert cc.pos.middle\n\ndef test_rotation():\n mbd = MockBlueDot()\n mbd.mock_client_connected()\n\n def rotation(dot, col, row):\n event_rotated = Event()\n dot.when_rotated = lambda: event_rotated.set()\n assert not event_rotated.is_set()\n\n #press the blue dot, no rotation\n mbd.mock_blue_dot_pressed(col,row,-0.1,1)\n assert not event_rotated.is_set()\n r = BlueDotRotation(mbd[col,row].interaction, mbd[0,0].rotation_segments)\n assert not r.valid\n assert r.value == 0\n assert not r.clockwise\n assert not r.anti_clockwise\n\n #rotate clockwise\n event_rotated.clear()\n mbd.mock_blue_dot_moved(col,row,0.1,1)\n assert event_rotated.is_set()\n r = BlueDotRotation(mbd[col,row].interaction, mbd[col,row].rotation_segments)\n assert r.value == 1\n assert r.valid\n assert r.clockwise\n assert not r.anti_clockwise\n\n #rotate anti-clockwise\n event_rotated.clear()\n mbd.mock_blue_dot_moved(col,row,-0.1,1)\n assert event_rotated.is_set()\n r = BlueDotRotation(mbd[col,row].interaction, mbd[col,row].rotation_segments)\n assert r.value == -1\n assert r.valid\n assert not r.clockwise\n assert r.anti_clockwise\n\n # background\n # rotate clockwise again\n event_rotated.clear()\n dot.set_when_rotated(lambda: delay_function(event_rotated.set, 0.2), background=True)\n mbd.mock_blue_dot_moved(col,row,0.1,1)\n assert not event_rotated.is_set()\n assert event_rotated.wait(1)\n\n rotation(mbd, 0, 0)\n rotation(mbd[0,0], 0, 0)\n\n mbd.resize(2,1)\n\n rotation(mbd, 1, 0)\n rotation(mbd[1,0], 1, 0)\n \ndef test_button_does_not_exist():\n mbd = MockBlueDot()\n \n with pytest.raises(ButtonDoesNotExist):\n button = mbd[0,1]\n \ndef test_allow_pairing():\n mbd = MockBlueDot()\n assert not mbd.adapter.discoverable\n assert not mbd.adapter.pairable\n\n mbd.allow_pairing()\n assert mbd.adapter.discoverable\n assert mbd.adapter.pairable\n\ndef test_dot_appearance():\n mbd = MockBlueDot()\n assert mbd.color == \"blue\"\n assert mbd.border == False\n assert mbd.square == False\n assert mbd.visible == True\n\n mbd.resize(2,1)\n\n for button in mbd.buttons:\n assert button.color == \"blue\"\n assert button.border == False\n assert button.square == False\n assert button.visible == True\n\n mbd[1,0].color = \"red\"\n mbd[1,0].border = True\n mbd[1,0].square = True\n mbd[1,0].visible = False\n\n assert mbd.color == \"blue\"\n assert mbd.border == False\n assert mbd.square == False\n assert mbd.visible == True\n \n assert mbd[0,0].color == \"blue\"\n assert mbd[0,0].border == False\n assert mbd[0,0].square == False\n assert mbd[0,0].visible == True\n\n assert mbd[1,0].color == \"red\"\n assert mbd[1,0].border == True\n assert mbd[1,0].square == True\n assert mbd[1,0].visible == False\n\n mbd.color = \"red\"\n mbd.border = True\n mbd.square = True\n mbd.visible = False\n\n assert mbd.color == \"red\"\n assert mbd.border == True\n assert mbd.square == True\n assert mbd.visible == False\n\n assert mbd[0,0].color == \"red\"\n assert mbd[0,0].border == True\n assert mbd[0,0].square == True\n assert mbd[0,0].visible == False\n\ndef test_dot_colors():\n from bluedot.colors import BLUE, RED, GREEN, YELLOW\n\n mbd = MockBlueDot()\n assert mbd.color == \"blue\"\n assert mbd.color == (0,0,255)\n assert mbd.color == BLUE\n assert mbd.color == \"#0000ff\"\n assert mbd.color == \"#0000ffff\"\n\n mbd.color = RED\n assert mbd.color == (255,0,0)\n assert mbd.color == \"red\"\n assert mbd.color == \"#ff0000\"\n assert mbd.color == \"#ff0000ff\"\n\n mbd.color = \"green\"\n assert mbd.color == GREEN\n assert mbd.color == (0,128,0)\n assert mbd.color == \"#008000\"\n assert mbd.color == \"#008000ff\"\n\n mbd.color = \"#ffff00\"\n assert mbd.color == YELLOW\n assert mbd.color == \"yellow\"\n assert mbd.color == (255,255,0)\n assert mbd.color == \"#ffff00ff\"\n\n mbd.color = \"#ffffff11\"\n assert mbd.color == \"#ffffff11\"\n\ndef delay_function(func, time):\n delayed_thread = Thread(target = _delayed_function, args = (func, time))\n delayed_thread.start()\n\ndef _delayed_function(func, time):\n sleep(time)\n func()"
},
{
"path": "tests/test_bluetooth_adapter.py",
"content": "import pytest\r\nfrom bluedot.btcomm import BluetoothAdapter\r\n\r\ntry:\r\n bta = BluetoothAdapter(\"hci0\")\r\nexcept Exception as e:\r\n if str(e) == \"Bluetooth adapter hci0 not found\":\r\n pytest.skip(\"Bluetooth adapter hci0 not found - skipping test\", allow_module_level = True)\r\n\r\ndef test_bluetooth_adapter():\r\n bta = BluetoothAdapter()\r\n assert bta.device == \"hci0\"\r\n assert len(bta.address) == 17\r\n\r\n # get the initial state of the adapter\r\n powered = bta.powered\r\n discoverable = bta.discoverable\r\n pairable = bta.pairable\r\n\r\n # flip the values back and forward\r\n bta.powered = not powered\r\n assert bta.powered == (not powered)\r\n bta.powered = powered\r\n assert bta.powered == powered\r\n\r\n # power up the adapter so discoverable and pairable can be tested\r\n bta.powered = True\r\n assert bta.powered == True\r\n\r\n bta.discoverable = not discoverable\r\n assert bta.discoverable == (not discoverable)\r\n bta.discoverable = discoverable\r\n assert bta.discoverable == discoverable\r\n\r\n bta.pairable = not pairable\r\n assert bta.pairable == (not pairable)\r\n bta.pairable = pairable\r\n assert bta.pairable == pairable\r\n\r\n bta.allow_pairing()\r\n assert bta.pairable == True\r\n assert bta.discoverable == True\r\n\r\n # reset the adapter back\r\n bta.powered = powered\r\n bta.discoverable = discoverable\r\n bta.pairable = pairable"
},
{
"path": "tests/test_bluetooth_comms.py",
"content": "import pytest\r\nfrom bluedot.btcomm import BluetoothAdapter, BluetoothServer, BluetoothClient\r\nfrom threading import Event\r\n\r\n# have we got 2 adapters\r\ntry:\r\n bta0 = BluetoothAdapter(\"hci0\")\r\n bta1 = BluetoothAdapter(\"hci1\")\r\nexcept Exception as e:\r\n pytest.skip(str(e) + \" - skipping test\", allow_module_level = True)\r\n\r\n# is adapter 0 paired with adapter 1 and vice versa\r\npaired = False\r\nfor device in bta0.paired_devices:\r\n if device[0] == bta1.address:\r\n paired = True\r\nif not paired:\r\n pytest.skip(\"hci0 is not paired with hci1\", allow_module_level = True)\r\n\r\npaired = False\r\nfor device in bta1.paired_devices:\r\n if device[0] == bta0.address:\r\n paired = True\r\nif not paired:\r\n pytest.skip(\"hci1 is not paired with hci0\", allow_module_level = True)\r\n\r\ndef test_server_default_values():\r\n def data_received(data):\r\n pass\r\n\r\n bts = BluetoothServer(data_received)\r\n assert bts.data_received_callback == data_received\r\n assert bts.device == \"hci0\"\r\n assert bts.server_address == bta0.address\r\n assert bts.running\r\n assert bts.port == 1\r\n assert bts.encoding == \"utf-8\"\r\n assert bts.when_client_connects == None\r\n assert bts.when_client_disconnects == None \r\n\r\n bts.stop()\r\n\r\ndef test_server_alt_values():\r\n def data_received(data):\r\n pass\r\n\r\n def when_client_connects():\r\n pass\r\n\r\n def when_client_disconnects():\r\n pass\r\n\r\n bts = BluetoothServer(\r\n data_received, \r\n device = \"hci1\", \r\n auto_start = False, \r\n port = 2, \r\n encoding = None, \r\n when_client_connects = when_client_connects, \r\n when_client_disconnects = when_client_disconnects)\r\n\r\n assert bts.data_received_callback == data_received\r\n assert bts.device == \"hci1\"\r\n assert bts.server_address == bta1.address\r\n assert not bts.running\r\n assert bts.port == 2\r\n assert bts.encoding == None\r\n assert bts.when_client_connects == when_client_connects\r\n assert bts.when_client_disconnects == when_client_disconnects\r\n\r\ndef test_server_start_stop():\r\n\r\n bts = BluetoothServer(None, auto_start = False)\r\n\r\n bts.start()\r\n assert bts.running\r\n\r\n bts.stop()\r\n assert not bts.running\r\n\r\ndef test_client_default_values():\r\n def data_received(data):\r\n pass\r\n\r\n bts = BluetoothServer(data_received, device = \"hci1\")\r\n btc = BluetoothClient(bta1.address, data_received)\r\n \r\n assert btc.data_received_callback == data_received\r\n assert btc.device == \"hci0\"\r\n assert btc.server == bta1.address\r\n assert btc.client_address == bta0.address\r\n assert btc.connected\r\n assert btc.port == 1\r\n assert btc.encoding == \"utf-8\"\r\n\r\n btc.disconnect()\r\n bts.stop()\r\n\r\ndef test_client_alt_values():\r\n def data_received(data):\r\n pass\r\n\r\n bts = BluetoothServer(None, port = 2, encoding = None)\r\n btc = BluetoothClient(bta0.address, data_received, device = \"hci1\", auto_connect = False, port = 2, encoding = None)\r\n \r\n assert btc.data_received_callback == data_received\r\n assert btc.device == \"hci1\"\r\n assert btc.client_address == bta1.address\r\n assert not btc.connected\r\n assert btc.port == 2\r\n assert btc.encoding == None\r\n\r\n btc.connect()\r\n assert btc.connected\r\n \r\n btc.disconnect()\r\n assert not btc.connected\r\n\r\n bts.stop()\r\n\r\ndef test_client_connect_disconnect():\r\n\r\n client_connected = Event()\r\n client_disconnected = Event()\r\n\r\n def when_client_connects():\r\n client_connected.set()\r\n\r\n def when_client_disconnects():\r\n client_disconnected.set()\r\n\r\n bts = BluetoothServer(None)\r\n btc = BluetoothClient(bta0.address, None, device = \"hci1\", auto_connect = False)\r\n bts.when_client_connects = when_client_connects\r\n bts.when_client_disconnects = when_client_disconnects\r\n\r\n btc.connect()\r\n assert btc.connected\r\n assert bts.client_address == btc.client_address\r\n assert client_connected.wait(1)\r\n \r\n btc.disconnect()\r\n assert not btc.connected\r\n assert client_disconnected.wait(1)\r\n\r\n bts.stop()\r\n\r\ndef test_send_receive():\r\n\r\n data_received_at_server = Event()\r\n data_received_at_client = Event()\r\n \r\n def data_received_server(data):\r\n assert data == \"hiserver\"\r\n data_received_at_server.set()\r\n\r\n def data_received_client(data):\r\n assert data == \"hiclient\"\r\n data_received_at_client.set()\r\n\r\n bts = BluetoothServer(data_received_server, device = \"hci0\")\r\n btc = BluetoothClient(bta0.address, data_received_client, device = \"hci1\")\r\n\r\n btc.send(\"hiserver\")\r\n assert data_received_at_server.wait(1)\r\n bts.send(\"hiclient\")\r\n assert data_received_at_server.wait(1)\r\n \r\n btc.disconnect()\r\n bts.stop()\r\n\r\ndef test_volume_data():\r\n\r\n from random import choice, randint\r\n import string\r\n\r\n no_of_transmissions = randint(100, 200)\r\n test_data = ''\r\n received = Event()\r\n\r\n def data_received_server(data):\r\n assert data == test_data\r\n bts.send(test_data)\r\n\r\n def data_received_client(data):\r\n assert data == test_data\r\n received.set()\r\n\r\n bts = BluetoothServer(data_received_server, device = \"hci0\")\r\n btc = BluetoothClient(bta0.address, data_received_client, device = \"hci1\")\r\n\r\n for test_no in range(no_of_transmissions):\r\n test_data = ''.join(choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(randint(30,100)))\r\n print(test_data)\r\n btc.send(test_data)\r\n assert received.wait(1)\r\n received.clear()\r\n \r\n btc.disconnect()\r\n bts.stop()\r\n"
}
]