<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.wellbeing.bioinfo">

    <uses-permission android:name="android.permission.WAKE_LOCK" />
    <uses-permission android:name="android.permission.BODY_SENSORS"/>
    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
    <uses-feature android:name="android.hardware.type.watch" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/wblogo"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@android:style/Theme.DeviceDefault">
        <uses-library
            android:name="com.google.android.wearable"
            android:required="true" />

        <!--
               Set to true if your app is Standalone, that is, it does not require the handheld
               app to run.
        -->
        <meta-data
            android:name="com.google.android.wearable.standalone"
            android:value="true" />

        <activity
            android:name=".MainActivity"
            android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name=".SensorJobService" android:exported="true" android:permission="android.permission.BIND_JOB_SERVICE"/>
    </application>

</manifest>

<?xml version="1.0" encoding="utf-8"?>
<androidx.wear.widget.BoxInsetLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/dark_grey"
    android:padding="@dimen/box_inset_layout_padding"
    tools:context=".MainActivity"
    tools:deviceIds="wear">

    <LinearLayout android:layout_height="match_parent" android:layout_width="match_parent" android:orientation="vertical">

        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="@string/hello_world"
            app:layout_box="all" />

        <Button
            android:id="@+id/start_btn"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Start" />

        <Button
            android:id="@+id/stop_btn"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Stop" />

    </LinearLayout>

    <TextView android:layout_height="wrap_content" android:layout_width="wrap_content" android:id="@+id/clock" app:layout_box="all" android:textColor="@android:color/white" android:layout_gravity="bottom|start"/>

</androidx.wear.widget.BoxInsetLayout>

package net.wellbeing.bioinfo;

import android.app.Activity;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.WindowManager;
import android.widget.TextView;

import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.common.api.ResultCallback;
import com.google.android.gms.wearable.MessageApi;
import com.google.android.gms.wearable.NodeApi;
import com.google.android.gms.wearable.Wearable;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class MainActivity extends Activity {
    private TextView mTextView;
    public ComponentName mServiceName;
    private final String TAG = MainActivity.class.getName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        mTextView = findViewById(R.id.text);
        mTextView.setTextSize(14.0f);

        CtrlFile ctrlfile = new CtrlFile();
        if( ctrlfile.checkfile() ) {
            mTextView.setText("Running.");
        }else{
            mTextView.setText("Stopped.");
        }

        mServiceName = new ComponentName(this, SensorJobService.class);

        findViewById(R.id.start_btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                CtrlFile file = new CtrlFile();
                if( file.checkfile() ) {
                    mTextView.setText("Already running");
                    return;
                }

                JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
                for (int i = 0; i < 1; i++) {
                    JobInfo jobInfo = new JobInfo.Builder(i, mServiceName)
                            .setMinimumLatency(1000)
                            .setOverrideDeadline(60000)
                            .setPersisted(true)
                            .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
                            .build();
                    scheduler.schedule(jobInfo);
                }

                file.createfile();
                mTextView.setText("Running");

            }
        });

        findViewById(R.id.stop_btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                CtrlFile file = new CtrlFile();
                file.deletefile();
                mTextView.setText("Stopped");
                JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
                scheduler.cancelAll();
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
    }

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

}

class SensorJobService extends JobService {
    private final String TAG = MainActivity.class.getName();

    @Override
    public boolean onStartJob(JobParameters params) {
        new ToastTask().execute(params);
        new SensorWorker().execute(params);

        CtrlFile file = new CtrlFile();
        if( !file.checkfile() ) {
            return true;
        }
        ComponentName mServiceName = new ComponentName(this, SensorJobService.class);

        JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        for (int i = 0; i < 1; i++) {
            JobInfo jobInfo = new JobInfo.Builder(i, mServiceName)
                    .setMinimumLatency(300*1000)
                    .setOverrideDeadline(180*1000)
                    .setPersisted(true)
                    .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY)
                    .build();
            scheduler.schedule(jobInfo);
        }
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }

    private class ToastTask extends AsyncTask<JobParameters, Void, String> {

        protected JobParameters mJobParam;

        @Override
        protected void onPreExecute() {

        }

        @Override
        protected String doInBackground(JobParameters... params) {
            mJobParam = params[0];
            return String.valueOf(mJobParam.getJobId());
        }

        @Override
        protected void onPostExecute(String result) {
            jobFinished(mJobParam, false);
        }
    }

    private class SensorWorker extends AsyncTask<JobParameters,Void,String> implements SensorEventListener {

        private final String TAG = MainActivity.class.getName();
        protected JobParameters mJobParam;

        private GoogleApiClient mGoogleApiClient;
        private SensorManager mSensorManager;
        private String mNode;

        private float x = 0, y = 0, z = 0;
        private int hr = 10;
        private float gyx = 0, gyy = 0, gyz = 0;
        private float lux = 100.0f;
        private int sc = 0;
        private int kcal = 0;
        int count = 0;

        @Override
        protected void onPreExecute() {

        }

        @Override
        protected String doInBackground(JobParameters... params) {
            mGoogleApiClient = new GoogleApiClient.Builder(getApplicationContext())
                    .addApi(Wearable.API)
                    .addConnectionCallbacks(new GoogleApiClient.ConnectionCallbacks() {
                        @Override
                        public void onConnected(Bundle bundle) {
                            Log.d(TAG, "onConnected");

                            Wearable.NodeApi.getConnectedNodes(mGoogleApiClient).setResultCallback(new ResultCallback<NodeApi.GetConnectedNodesResult>() {
                                @Override
                                public void onResult(NodeApi.GetConnectedNodesResult nodes) {
                                    if (nodes.getNodes().size() > 0) {
                                        mNode = nodes.getNodes().get(0).getId();

                                    }
                                }
                            });
                        }

                        @Override
                        public void onConnectionSuspended(int i) {
                            Log.d(TAG, "onConnectionSuspended");

                        }
                    })
                    .addOnConnectionFailedListener(new GoogleApiClient.OnConnectionFailedListener() {
                        @Override
                        public void onConnectionFailed(ConnectionResult connectionResult) {
                            Log.d(TAG, "onConnectionFailed : " + connectionResult.toString());
                        }
                    })
                    .build();

            mGoogleApiClient.connect();

            mSensorManager = (SensorManager)getSystemService(SENSOR_SERVICE);

            Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
            mSensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL*5);

            Sensor gySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
            mSensorManager.registerListener(this, gySensor, SensorManager.SENSOR_DELAY_NORMAL*5);

            try {
                Thread.sleep(3*1000);
                //wait();
            }catch(Exception e) {

            }
            mSensorManager.unregisterListener(this);

            Sensor hrSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_HEART_RATE);
            mSensorManager.registerListener(this, hrSensor, SensorManager.SENSOR_DELAY_NORMAL);

            //Sensor hbSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_HEART_BEAT);
            //mSensorManager.registerListener(this, hbSensor, SensorManager.SENSOR_DELAY_NORMAL);

            Sensor scSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
            mSensorManager.registerListener(this, scSensor, SensorManager.SENSOR_DELAY_NORMAL);

            Sensor luxSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
            mSensorManager.registerListener(this, luxSensor, SensorManager.SENSOR_DELAY_NORMAL);

            Sensor kcalSensor = mSensorManager.getDefaultSensor(65548);
            mSensorManager.registerListener(this, kcalSensor, SensorManager.SENSOR_DELAY_NORMAL);

            int i=0;
            while( i < 3 ) {
                if( hr > 10 &amp;&amp; lux != 0 ){
                    break;
                }
                try {
                    Thread.sleep(10*1000);
                    //wait();
                }catch(Exception e) {

                }
                i++;

            }

            mJobParam = params[0];
            return String.valueOf(mJobParam.getJobId());
        }

        @Override
        protected void onPostExecute(String result) {
            mSensorManager.unregisterListener(this);

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss z");

            String SEND_DATA = sdf.format(Calendar.getInstance().getTime()) + "," + x + "," + y + "," + z + "," + hr + "," + lux + "," + sc;
            if (mNode != null) {
                Wearable.MessageApi.sendMessage(mGoogleApiClient, mNode, SEND_DATA, null).setResultCallback(new ResultCallback<MessageApi.SendMessageResult>() {
                    @Override
                    public void onResult(MessageApi.SendMessageResult result) {
                        if (!result.getStatus().isSuccess()) {
                            Log.d(TAG, "ERROR : failed to send Message" + result.getStatus());
                        }
                    }
                });
            }

            jobFinished(mJobParam, false);
        }

        @Override
        public void onSensorChanged(SensorEvent event) {

            if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
                x = event.values[0];
                y = event.values[1];
                z = event.values[2];
            }

            else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
                gyx = event.values[0];
                gyy = event.values[1];
                gyz = event.values[2];
            }

            else if (event.sensor.getType() == Sensor.TYPE_LIGHT) {
                lux = event.values[0];
            }

            else if (event.sensor.getType() == Sensor.TYPE_HEART_RATE) {
                int h = hr;
                hr =(int)event.values[0];
                if( hr == 255 ){
                    hr = h;
                }
            }

            else if (event.sensor.getType() == Sensor.TYPE_STEP_COUNTER) {
                sc = (int) event.values[0];
            }

            else if (event.sensor.getType() == 65548) {
                kcal = (int) event.values[0];
            }

        }

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

    }
}

class CtrlFile {
    private String filename = "/data/data/net.wellbeing.bioinfo/log.txt";

    public boolean checkfile() {
        File file = new File(filename);
        return( file.exists() );
    }

    public boolean createfile() {
        FileOutputStream fos;
        try {
            //fos = openFileOutput(fileName, Context.MODE_PRIVATE);
            fos = new FileOutputStream(new File(filename));
            fos.write(new Date().toString().getBytes());
        } catch (IOException e) {
            String path = new File(".").getAbsoluteFile().getParent();
            e.printStackTrace();
            return(false);
        }
        return(true);
    }
    public boolean deletefile() {
        File file = new File(filename);
        return(file.delete());
    }
}