Smartified Stove Control with LEGO EV3 and Alexa

/*
 * This is an Alexa Skill named "Stove Control". Its main function is to turn off a stove by rotating the knob
 * to its off position based on a timer.
 * 
 * The main intent is "StoveOffTimerIntent".
 *
 * Other intents are used to calibrate the current position of the knob so that EV3 knows the offset to the off 
 * position.
*/

const Alexa = require('ask-sdk-core');
const Util = require('./util');
const Common = require('./common');

// The audio tag to include background music
const BG_MUSIC = '<audio src="soundbank://soundlibrary/ui/gameshow/amzn_ui_sfx_gameshow_waiting_loop_30s_01"></audio>';


// The namespace of the custom directive to be sent by this skill
const NAMESPACE = 'Custom.Mindstorms.Gadget';

// The name of the custom directive to be sent this skill
const NAME_CONTROL = 'control';

const LaunchRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'LaunchRequest';
    },
    handle: async function(handlerInput) {

        let request = handlerInput.requestEnvelope;
        let { apiEndpoint, apiAccessToken } = request.context.System;
        let apiResponse = await Util.getConnectedEndpoints(apiEndpoint, apiAccessToken);
        if ((apiResponse.endpoints || []).length === 0) {
            return handlerInput.responseBuilder
            .speak(`I couldn't find an EV3 Brick connected to this Echo device. Please check to make sure your EV3 Brick is connected, and try again.`)
            .getResponse();
        }

        // Store the gadget endpointId to be used in this skill session
        let endpointId = apiResponse.endpoints[0].endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Set skill duration to 5 minutes (ten 30-seconds interval)
        //Util.putSessionAttribute(handlerInput, 'duration', 10);

        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        Util.putSessionAttribute(handlerInput, 'token', token);


        return handlerInput.responseBuilder
            .speak("Welcome to smartified stove, you can start issuing stove control commands")
            .reprompt("Awaiting commands" + BG_MUSIC)
            .getResponse();
    }
};

const StoveOffTimerIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'StoveOffTimerIntent';
    },
    handle: function (handlerInput) {
        const request = handlerInput.requestEnvelope;
        var timer_mins = Alexa.getSlotValue(request, 'timer_mins');
        var timer_secs = Alexa.getSlotValue(request, 'timer_secs');
        
        if (timer_mins === undefined){
            timer_mins = 0;
        }
        else {
            timer_mins = parseInt(timer_mins);
        }
        
        if (timer_secs === undefined){
            timer_secs = 0;
        }
        else {
            timer_secs = parseInt(timer_secs);
        }
        
        const delay = parseInt(timer_mins) * 60 + parseInt(timer_secs);

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Construct the directive with the payload containing the stove control parameters
        const directive = Util.build(endpointId, NAMESPACE, NAME_CONTROL,
            {
                type: "StoveOffTimer",
                delay: delay
            });
            
        var secs_str = "";
        
        if (timer_secs !== 0){
            if (timer_secs === 1){
                secs_str = "one second";
            }
            else {
                secs_str = timer_secs + "seconds";
            }
        }
        
        var mins_str = "";
        
        if (timer_mins !== 0){
            if (timer_mins === 1){
                mins_str = "one minute";
            }
            else {
                mins_str = timer_mins + " minutes";     
            }
            
            if (timer_secs > 0){
                mins_str = mins_str + " and ";
            }
        }


        return handlerInput.responseBuilder
                .speak("the stove will be turned off in " + mins_str + secs_str)
                .addDirective(directive)
                .getResponse();    
    }
};

const MoveIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'MoveToPositionIntent';
    },
    handle: function (handlerInput) {
        const request = handlerInput.requestEnvelope;
        const hour = Alexa.getSlotValue(request, 'hour');

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Construct the directive with the payload containing the move parameters
        const directive = Util.build(endpointId, NAMESPACE, NAME_CONTROL,
            {
                type: 'Move',
                position: hour
            });

        
        return handlerInput.responseBuilder
            .speak("Rotating the knob to " + hour + " o'clock")
            .reprompt("awaiting command")
            .addDirective(directive)
            .getResponse();
    }
};


const ReverseRotateIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'ReverseRotateIntent';
    },
    handle: function (handlerInput) {
        const request = handlerInput.requestEnvelope;
        const count = Alexa.getSlotValue(request, 'count');

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Construct the directive with the payload containing the move parameters
        const directive = Util.build(endpointId, NAMESPACE, NAME_CONTROL,
            {
                type: 'ReverseRotate',
                degrees: count
            });

        
        return handlerInput.responseBuilder
            .speak("Rotating the knob " + count + " degrees counter-clockwise")
            .reprompt("awaiting command")
            .addDirective(directive)
            .getResponse();
    }
};


const RotateIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'RotateIntent';
    },
    handle: function (handlerInput) {
        const request = handlerInput.requestEnvelope;
        const count = Alexa.getSlotValue(request, 'count');

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Construct the directive with the payload containing the move parameters
        const directive = Util.build(endpointId, NAMESPACE, NAME_CONTROL,
            {
                type: 'Rotate',
                degrees: count
            });

        
        return handlerInput.responseBuilder
            .speak("Rotating the knob " + count + " degrees clockwise")
            .reprompt("awaiting command")
            .addDirective(directive)
            .getResponse();
    }
};

const CalibrateIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'CalibrateIntent';
    },
    handle: function (handlerInput) {
        const request = handlerInput.requestEnvelope;
        const position = Alexa.getSlotValue(request, 'position');

        const attributesManager = handlerInput.attributesManager;
        const endpointId = attributesManager.getSessionAttributes().endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

        // Construct the directive with the payload containing the move parameters
        const directive = Util.build(endpointId, NAMESPACE, NAME_CONTROL,
            {
                type: 'Calibrate',
                position: position
            });

        
        return handlerInput.responseBuilder
            .speak("Calibrting the current position as " + position + " o'clock")
            .reprompt("awaiting command")
            .addDirective(directive)
            .getResponse();
    }
};


// The SkillBuilder acts as the entry point for your skill, routing all request and response
// payloads to the handlers above. Make sure any new handlers or interceptors you've
// defined are included below. The order matters - they're processed top to bottom.
exports.handler = Alexa.SkillBuilders.custom()
    .addRequestHandlers(
        LaunchRequestHandler,
        StoveOffTimerIntentHandler,
        MoveIntentHandler,
        RotateIntentHandler,
        ReverseRotateIntentHandler,
        CalibrateIntentHandler,
        Common.HelpIntentHandler,
        Common.CancelAndStopIntentHandler,
        Common.SessionEndedRequestHandler,
        Common.IntentReflectorHandler, // make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers
    )
    .addRequestInterceptors(Common.RequestInterceptor)
    .addErrorHandlers(
        Common.ErrorHandler,
    )
    .lambda();