public class SensorWrangler implements SensorEventListener {

        private float[] currentData = new float[3];
        private SensorManager sensorManager;

        public SensorWrangler(Context context) {
            sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
            // register your sensors - really you want to register/unregister in a separate method,
	    // that you can call from onResume/onPause to pause and restart the sensors as required
            Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
            sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL);
        }


        @Override
        public void onSensorChanged(SensorEvent event) {
            // doot doot
            if (event.sensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION) {
                currentData = Arrays.copyOf(event.values, event.values.length);
            }
        }


        @Override
        public void onAccuracyChanged(Sensor sensor, int accuracy) { }


        public float[] getCurrentData() {
            return currentData;
        }

}

public class MainActivity extends Activity {

    // call this on the main thread and it gets the main thread's Handler
    private Handler handler = new Handler();
    private SensorWrangler wrangler;

    private static final int UPDATE_DELAY = 100;
    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = (TextView) findViewById(R.id.textview);
        wrangler = new SensorWrangler(getApplicationContext());
        // post the updating task so it will fire - giving it the usual 100ms delay here
        handler.postDelayed(updateTask, UPDATE_DELAY);
    }


    private Runnable updateTask = new Runnable() {
        public void run() {
            // poll for data and do whatever with it
            float[] data = wrangler.getCurrentData();
            textView.setText(String.format("X:%.4f\nY:%.4f\nZ:%.4f", data[0], data[1], data[2]));
            // throw the task back on the conveyor belt
            handler.postDelayed(this, UPDATE_DELAY);
        }
    };
}

baka kaba fucked around with this message at 01:42 on Jul 14, 2015

baka kaba fucked around with this message at 19:32 on Jul 14, 2015

hooah fucked around with this message at 23:45 on Jul 17, 2015

• When onCreate is called you put the runnable on the message queue with a delayed timestamp
  
• The main thread checks the message queue every so often to see if it has any tasks it needs to run
  
• If your task is next, and its timestamp says it's due to run, the thread calls run() on the Runnable that was passed in
  
• It executes the code that's in run() until that method returns. Part of that code is reposting the same runnable object on the message queue, with a delay.
  
• Later the queue hits your runnable again and it's time to run it...
  

hooah fucked around with this message at 21:28 on Jul 18, 2015

// Displays the motion data
public class DisplayData extends Activity {
    private SensorWrangler mWrangler;
    private HandlerThread mHandlerThread = new HandlerThread("dataThread");
    private Looper mLooper;
    private Handler mHandler;

    private static final long UPDATE_DELAY = 250L;
    private static final String TAG = "DisplayData";

    private Runnable updateTask = new Runnable() {
        public void run() {
            // poll for data and do whatever with it
            float[][] data = mWrangler.getCurrentData();
            updateViews(data);
            // throw the task back on the conveyor belt
            mHandler.postDelayed(this, UPDATE_DELAY);
        }
    };

    private TextView mLinXText;
    private TextView mLinYText;
    private TextView mLinZText;
    private TextView mRotXText;
    private TextView mRotYText;
    private TextView mRotZText;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // initialise the Wrangler (with the context it needs to get a SensorManager)
        mWrangler = new SensorWrangler(getApplicationContext());

        // Set up the and Looper and Handler
        mHandlerThread.start();
        mLooper = mHandlerThread.getLooper();
        mHandler = new Handler(mLooper);

        // post the updating task so it will fire - giving it the usual 100ms delay here
        mHandler.postDelayed(updateTask, UPDATE_DELAY);

        setContentView(R.layout.activity_display_data);
        mLinXText = (TextView) findViewById(R.id.LinXCoord);
        mLinYText = (TextView) findViewById(R.id.LinYCoord);
        mLinZText = (TextView) findViewById(R.id.LinZCoord);
        mRotXText = (TextView) findViewById(R.id.RotXCoord);
        mRotYText = (TextView) findViewById(R.id.RotYCoord);
        mRotZText = (TextView) findViewById(R.id.RotZCoord);

    }

    @Override
    protected void onPause(){
        super.onPause();
        mWrangler.sleep();
    }

    protected void onResume(){
        super.onResume();
        mWrangler.wake();
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    /** Called when the user clicks the Stop button */
    public void stopCollect(View view) {
        mHandler.removeCallbacks(updateTask);
        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
    }

    /* Checks if external storage is available for read and write */
    public boolean isExternalStorageWritable() {
        String state = Environment.getExternalStorageState();
        if (Environment.MEDIA_MOUNTED.equals(state)) {
            return true;
        }
        return false;
    }

    public File getDataStorageDir(String dataName) {
        // Get the directory for the user's public pictures directory.
        File file = new File(Environment.getExternalStoragePublicDirectory(
                Environment.DIRECTORY_DOWNLOADS), dataName);
//        if (!file.mkdirs()) {
//            Log.e(TAG, "Directory not created");
//        }
        return file;
    }

    /** Display the updated information */
    public void updateViews(float[][] data) {
        float[] accelData = data[0];
        float[] rotData = data[1];

        mLinXText.setText(Float.toString(accelData[0]));
        mLinYText.setText(Float.toString(accelData[1]));
        mLinZText.setText(Float.toString(accelData[2]));

        mRotXText.setText(Float.toString(rotData[0]));
        mRotYText.setText(Float.toString(rotData[1]));
        mRotZText.setText(Float.toString(rotData[2]));

        FileOutputStream outputStream;
        try {
            if(isExternalStorageWritable()) {
                File path = getDataStorageDir("MotionCapture");
                File file = new File(path, "data.txt");
                outputStream = new FileOutputStream(file, true);
                StringBuilder myBuilder = new StringBuilder();
                myBuilder.append(System.currentTimeMillis());
                myBuilder.append(',');
                myBuilder.append(accelData[0]);
                myBuilder.append(',');
                myBuilder.append(accelData[1]);
                myBuilder.append(',');
                myBuilder.append(accelData[2]);
                myBuilder.append(',');
                myBuilder.append(rotData[0]);
                myBuilder.append(',');
                myBuilder.append(rotData[1]);
                myBuilder.append(',');
                myBuilder.append(rotData[2]);
                myBuilder.append('\n');

                outputStream.write(myBuilder.toString().getBytes());
                outputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

hooah fucked around with this message at 14:26 on Jul 20, 2015

public class Wow implements Runnable {
	public void run() {
		// post this runnable to the DANGER THREAD's handler, all this runs on DANGER THREAD
		doSomething();
		doOtherThing();
		runOnUiThread(new Runnable() {
			public void run() {
				// This is only getting run on the UI thread, so it's safe!
				pokeUiElements();
			}
		});
	}
}

baka kaba fucked around with this message at 20:58 on Jul 20, 2015

kitten smoothie fucked around with this message at 15:55 on Jul 21, 2015

baka kaba fucked around with this message at 16:01 on Jul 21, 2015