Best way to programming this app?

My json resource file looks like this, so it is different format from yours:

<jsonDataResources>
   	<jsonData id="singleValue">
        3.14
   	</jsonData>
</jsonDataResources>

On the communication side of CIQ, I've never tried it, so can't help

Thanks! I solved it yesterday, with a sample from the garmin guide. It looks like yours.

The problem i have now is how to get the accelerometre and hearth rate data, and how to communicate it.

Iker Arana said:

The problem i have now is how to get the accelerometre and hearth rate data, and how to communicate it.

If you want to receive the data in your app and then do stuff with it, you can use the Sensor module and access the data directly:

using Toybox.WatchUi;
using Toybox.Sensor;

class MyBehaviorDelegate extends WatchUi.BehaviorDelegate
{
    hidden var _enabled;
    
    function initialize() {
        _enabled = false;
    }

    function onSelect() {

        _enabled = !_enabled;
        if (_enabled) {
        
            // enable support for external heart rate sensors
            Sensor.setEnabledSensors([ Sensor.SENSOR_HEARTRATE ]);
            
            // start receiving low frequency data (heart rate)
            Sensor.enableSensorEvents(self.method(:onLowFrequencyData));
            
            // var options = {
            //    :period => 1,           // invoke the callback once a second
            //    :accelerometer => {
            //        :enabled => true,
            //        :sampleRate => 25,  // 25 samples/second
            ////        :includePower => true,
            ////        :includePitch => true,
            ////        :includeRoll => true,
            //    },
            //    :heartBeatIntervals => {
            //        :enabled => true
            //    }
            //};
            
            //// start receiving high frequency accelerometer and beat-to-beat interval data
            //Sensor.registerSensorDataListener(self.method(:onHighFrequencyData), options);
        }
        else {
            //// stop receiving high frequency sensor updates
            //Sensor.unregisterSensorDataListener();
            
            // stop receiving low frequency sensor updates
            Sensor.enableSensorEvents(null);
            
            // disable the heart rate sensor
            Sensor.setEnabledSensors([]);
        }
        
        return true;
    }
    
    function onLowFrequencyData(sensorInfo) {
        System.println("Heart Rate   : " + sensorInfo.heartRate);
        System.println("Accelerometer: " + sensorInfo.accel); // array of [ X, Y, Z ]
        System.println("Magnetometer : " + sensorInfo.mag);   // array of [ X, Y, Z ]
    }
    
    function onHighFrequencyData(sensorData) {
        var accelerometerData = sensorData.accelerometerData;
        if (accelerometerData) {
            // you'll want to process the data here
            
            // these should have 25 samples of accel data each
            // accelerometerData.x;
            // accelerometerData.y;
            // accelerometerData.z;

            // if you requested these when registering for high frequency data
            // accelerometerData.pitch;
            // accelerometerData.roll;
            // accelerometerData.power;
        }

        var heartRateData = sensorData.heartRateData;
        if (heartRateData != null) {
            // you'll want to process the data here

            // expect 0-5 beat-to-beat intervals
            // heartRateData.heartBeatIntervals; // array of beat intervals in milliseconds
        }
    }
}

If you just want to record the data to FIT file and analyze it offline, you'd also have to create a recording session and enable logging of the accelerometer data. You don't want to record for an extended period of time since it is throwing data into the file at ~300 bytes/second.

        if (_session == null) {
            // setup sensor logger to enable recording of accelerometer
            // data. don't leave this recording for long, it is recording
            // lots of data
            var sensorLogger = new SensorLogging.SensorLogger({
                                    :accelerometer => {
                                        :enabled => true
                                    }
                                });

            _session = ActivityRecording.createSession({
                 :name => "Generic",
                 :sport => ActivityRecording.SPORT_GENERIC,
                 :subSport => ActivityRecording.SUB_SPORT_GENERIC,
                 :sensorLogger => sensorLogger
            });
            _session.start();
        }
        else {
            _session.stop();
            _session.save();
            _session = null;
        }

Thanks Travis!

I am a novice with Eclipse and Connect IQ and i am currently trying and testing simple apps reading the Garmins guide to get fluent with the enviroment.

What i want to do with my App is just monitor hearth rate and accelerometre data and when some event is triggered i would like to store this data during this events, with the aim off process it later in a remote server. 

In your replay you said me "You don't want to record for an extended period of time since it is throwing data into the file at ~300 bytes/second.". So, on this basis, i think that i have 2 options:

• Store the data in the watch during the event and once it has finished send to the mobile phone and pull to the server
• Send the data in real time to the mobile phone, store it there and then pull.

I am not sure about how long an event could be (i have asked to my supervisor about it). But i think that the first option will be the best to start.

I will try to test your code to get sensor data this week. 

But my questions now are:

• The best way to save the data in a file (in the watch)
• How to send this file to a mobile phone 

By the way, the "recording sesion"  you said above, is like use a thread to get data? i think this will be the best way to save the data for this particular purpose. What is your recomendation?

Hope you can help me.

Thanks and regards!

The ConnectIQ platform doesn't provide a generic File API. If you want to store data, there are really only a few ways to do it.

1. Store the data using ActivityRecording.Session (in a FIT file)
2. Cache the data using Application.Storage
   1. Push the data off device using Communications.makeWebRequest
   2. Push the data off device using Communications.transmit

There are actually two different ways to handle the first. Both involve creating a Session via a call to ActivityRecording.createSession(). In one case, you can provide a :sensorLogger attribute to the createSession call (see the PitchCounter sample app). In this case a lot of data will be written to the FIT file.. The X/Y/Z accelerometer data is 3 floats (12 bytes) and there could be as many as 25 samples per second. The second way would be to not use the sensorLogger, but to use the functionality in the FitContributor module. In this case, you'd probably not write all of the accelerometer data to the fit file, you'd do the calculation on device and set the field value to indicate the detected event or state change.

Using the FIT file has the advantage that you don't really need to do anything to get the file off the device as it would be automatically uploaded to Garmin Connect. You'd need to provide a way to get the original FIT file out of Garmin Connect, which is a separate issue entirely.

The Application.Storage module is more convenient, but more limiting since there are limitations on the amount of data you can store in the file. You'd probably need to cache data on the device to handle the case that your phone/internet connection is not always available. If you can keep the amount of data you need to cache relatively small (say by only caching a fixed number of records), this could be made to work.

Thanks again Travis!

First, i have been working with the sensor events example you send me in your last response and it works well. I will try to work with the session example on next week. Hope i won´t have problems.

About the Sensors Data Management. I have read all the posibilities you told me. My main goal is to not lose any data, so if there is any way to get the FIT file from Garmin Connect, i think this is the best option. Besides, the communication problem is solved.

About the Application.Storage module, you said there exist limitations on the amount of data to store in a file and i have to cache it in the device. I have a doubt here, when you talk about cache data, is this a way to been able to write all the data in the file or is just a way to save the files until you have connection with the phone?. 

This is just a way for you to save data that is associated with your application. My thought was that you might be able to cache your data into app storage as it is recorded, and then upload it and clear the cache when a connection became available. As you suggested, the FIT file route essentially does this all for you and it isn't as limited with the amount of data it can store.

Ok. 

I will try to do it on next week and I will give you some feedback about how it was. 

Because of you said, the problem using this method would be to find the FIT file in the phone, once you have sent it. Do you know how I can do it? I suppose that does not exist any Android API to do this task... 

Iker Arana said:

the problem using this method would be to find the FIT file in the phone

You don't find the FIT file on the phone. It may be cached on the phone temporarily, but it will not be stored there long term. You'd have to download the FIT file from Garmin Connect. For example, this is a previously uploaded FIT file from my Edge cycling computer:

  https://connect.garmin.com/modern/activity/3728700768

If you use the Garmin Connect API, you should be able to programmatically find recent uploads for a given ConnectIQ account and then download the FIT file.

Ok. 

If I understood correctly, your purposed approach is the next: once the FIT file is in the phone/Connect App, it will be temporary stored. So, using the mobile app programming SDK I might be able to make a program and get this file before it is deleted. Is this correct?