alexaTVAdvanced

'use strict';

var WebSocket = require('ws');
var request = require('request');
var uuid = require('uuid-v4');

/**
 * This sample demonstrates a smart home skill using the publicly available API on Amazon's Alexa platform.
 * For more information about developing smart home skills, see
 *  https://developer.amazon.com/alexa/smart-home
 *
 * For details on the smart home API, please visit
 *  https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference
 */

const USER_DEVICES = [
    {
        // This id needs to be unique across all devices discovered for a given manufacturer
        endpointId: '40163BEAC7DC', //TV Mac
        // The name given by the user in your application. Examples include 'Bedroom light' etc
        friendlyName: 'Fernseher',
        // Should describe the device type and the company/cloud provider.
        // This value will be shown in the Alexa app
        description: 'Smart TV Wohnzimmer',
        // Company name that produces and sells the smart home device
        manufacturerName: 'Samsung',
        displayCategories: ['TV'],
        // not used at this time
        cookie: {
            extraDetail1: 'a',
            extraDetail2: 'b',
            extraDetail3: 'c',
            extraDetail4: 'd',
        },
        capabilities: [
            {
              "type": "AlexaInterface",
              "interface": "Alexa.PowerController",
              "version": "3",
              "properties": {
                "supported": [
                  {
                    "name": "powerState"
                  }
                ],
                "proactivelyReported": false,
                "retrievable": false
              }
            } ]
        }
];

/**
 * Utility functions
 */

function log(title, msg) {
    console.log(`[${title}] ${msg}`);
}

/**
 * Generate a unique message ID
 *
 * TODO: UUID v4 is recommended as a message ID in production.
 */
function generateMessageID() {

    return uuid();
}

function generateTimeStamp() {

    var time = new Date();

    return time.toISOString();
}

/**
 * Generate a response message
 *
 * @param {Object} request - request.directive object
 * @param {string} eventType - eventType e.g. Response or StateReport
 * @param {Object} contextProperties - static array of values to report
 * @param {Object} payload - Any special payload required for the response
 * @returns {Object} Response object
 */
function generateResponse(request, eventType, contextProperties, payload) {
    return {
        context: {
            properties: contextProperties
        },
        event: {
        header: {
            messageId: generateMessageID(),
            namespace: 'Alexa',
            name: eventType,
            correlationToken: request.header.correlationToken,
            payloadVersion: '3'
        },
        endpoint:{
            scope: {
                type: 'BearerToken',
                token: request.endpoint.scope.token
            },
            endpointId: request.endpoint.endpointId
        },
        payload: payload
        }
    };
}

/**
 * Functions to access device cloud.
 */

function getDevicesFromPartnerCloud() {

    return USER_DEVICES;
}

function transmitCommandToPi(cmdJson) {

    var socket;

    console.log("Send Cmd to TV: " + cmdJson);

    return new Promise((resolve, reject) => {

        socket = new WebSocket('http://' + 'wkyg3jni0whrfyk6.myfritz.net' + ':9090', function (error) {
            console.log(new Error(error).toString());

            reject("SocketError");
            return;
        });

        socket.on('error', function (e) {
            console.log('Error in WebSocket communication');
            socket.close();

            reject("SocketError");
            return;
        });

        socket.on('message', function (msg) {

            console.log("incoming message: ", msg);

            if (msg == "[REQUEST]") {

                socket.send("[TVCMD]=" + cmdJson);
            }
            else if (msg.startsWith("[END]")) {
                let status = msg.substr(msg.indexOf('=') + 1);

                console.log("Cmd END received with status: " + status + ". Shut down socket!");

                socket.close();

                resolve(status);
            }
        });
    });
}

//request, name, value, payload

function turnTVOn(request, applianceId) {
    log('DEBUG', `turnOn (applianceId: ${applianceId})`);

    var tvCmd = "WOL";

    return new Promise((resolve, reject) => {

        // Call device cloud's API to turn on the device
        transmitCommandToPi(tvCmd).then((successMsg, error) => {

            if (error) {
                const errorMessage = `Leider ist bei der �bermittlung des TV Befehls ein Problem aufgetreten!`;
                log('ERROR', errorMessage);

                reject(generateResponse(request, 'UnsupportedOperationError', {}, {}));
            }
            else {
                if (successMsg == "Delay") {

                    var contextProperties = [{
                        namespace: request.header.namespace,
                        name: "powerState",
                        value: "ON",
                        timeOfSample: generateTimeStamp(),
                        uncertaintyInMilliseconds: 30000 //30 seconds due TV connection lag
                    }];

                    resolve(generateResponse(request, "Response", contextProperties, {}));
                }
                else {

                    const errorMessage = `TV is already on!`;
                    log('ERROR', errorMessage);

                    reject(generateResponse(request, 'UnsupportedOperationError', {}, {}));
                }
            }
        });
    });
}

function turnTVOff(request, applianceId) {
    log('DEBUG', `turnOff (applianceId: ${applianceId})`);

    var tvCmd = { method: "ms.remote.control", params: { Cmd: "Click", DataOfCmd: "KEY_POWER", Option: "false", TypeOfRemote: "SendRemoteKey", to: "host" } };

    return new Promise((resolve, reject) => {

        transmitCommandToPi(JSON.stringify(tvCmd)).then((successMsg, error) => {

            if (error) {
                const errorMessage = `Leider ist bei der �bermittlung des TV Befehls ein Problem aufgetreten!`;
                log('ERROR', errorMessage);

                reject(generateResponse(request, 'UnsupportedOperationError', {}, {}));
            }
            else {

                if (successMsg == "tvOff") {
                    const errorMessage = `TV is already off!`;
                    log('ERROR', errorMessage);

                    reject(generateResponse(request, 'UnsupportedOperationError', {}, {}));
                }
                else {

                    var contextProperties = [{
                        namespace: request.header.namespace,
                        name: "powerState",
                        value: "OFF",
                        timeOfSample: generateTimeStamp(),
                        uncertaintyInMilliseconds: 2000 //2 seconds due TV connection lag
                    }];

                    resolve(generateResponse(request, "Response", contextProperties, {}));
                }
            }
        });
    });
}


/**
 * Main logic
 */

/**
 * This function is invoked when we receive a "Discovery" message from Alexa Smart Home Skill.
 * We are expected to respond back with a list of appliances that we have discovered for a given customer.
 *
 * @param {Object} request - The full request object from the Alexa smart home service. This represents a DiscoverAppliancesRequest.
 *     https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference#discoverappliancesrequest
 *
 * @param {function} callback - The callback object on which to succeed or fail the response.
 *     https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html#nodejs-prog-model-handler-callback
 *     If successful, return <DiscoverAppliancesResponse>.
 *     https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference#discoverappliancesresponse
 */

 function handleAuth(request, callback) {

    console.log("User Tokens for Message Gateway: " + request);

    const response = {
        event: {
            header: {
                messageId: generateMessageID(),
                name: 'AcceptGrant.Response',
                namespace: 'Alexa.Authorization',
                payloadVersion: '3',
            },
            payload: {
            },
        }
    };

    callback(null, response);

 }

function handleDiscovery(request, callback) {
    log('DEBUG', `Discovery Request: ${JSON.stringify(request)}`);

    /**
     * Get the OAuth token from the request.
     */
    const userAccessToken = request.payload.scope.token.trim();

    if (!userAccessToken) {
        const errorMessage = `Discovery Request [${request.header.messageId}] failed. Invalid access token: ${userAccessToken}`;
        log('ERROR', errorMessage);
        callback(new Error(errorMessage));
    }

    /**
     * Assume access token is valid at this point.
     * Retrieve list of devices from cloud based on token.
     *
     * For more information on a discovery response see
     *  https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference#discoverappliancesresponse
     */
    const response = {
        event: {
            header: {
                messageId: generateMessageID(),
                name: 'Discover.Response',
                namespace: 'Alexa.Discovery',
                payloadVersion: '3',
            },
            payload: {
                endpoints: getDevicesFromPartnerCloud(userAccessToken),
            },
        }
    };

    /**
     * Log the response. These messages will be stored in CloudWatch.
     */
    log('DEBUG', `Discovery Response: ${JSON.stringify(response)}`);

    /**
     * Return result with successful message.
     */
    callback(null, response);
}

/**
 * A function to handle power control events.
 * This is called when Alexa requests an action such as turning off an appliance.
 *
 * @param {Object} request - The full request object from the Alexa smart home service.
 * @param {function} callback - The callback object on which to succeed or fail the response.
 */
function handlePowerControl(request, callback) {
    log('DEBUG', `Control Request: ${JSON.stringify(request)}`);

    /**
     * Get the access token.
     */
    const userAccessToken = request.endpoint.scope.token.trim();

    if (!userAccessToken) {
        log('ERROR', `Power Request [${request.header.messageId}] failed. Invalid access token: ${userAccessToken}`);
        callback(null, generateResponse(request, 'InvalidAccessTokenError', {}, {}));
        return;
    }

    /**
     * Grab the applianceId from the request.
     */
    const applianceId = request.endpoint.endpointId;

    /**
     * If the applianceId is missing, return UnexpectedInformationReceivedError
     *  https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference#unexpectedinformationreceivederror
     */
    if (!applianceId) {
        log('ERROR', 'No applianceId provided in request');
        const payload = { faultingParameter: `applianceId: ${applianceId}` };
        callback(null, generateResponse(request, 'UnexpectedInformationReceivedError', {}, payload));
        return;
    }

    /**
     * At this point the applianceId and accessToken are present in the request.
     *
     */

    let response;

    switch (request.header.name) {
        case 'TurnOn': {
            turnTVOn(request, applianceId).then((successMsg, error) => {

                if (error)
                    response = error;
                else
                    response = successMsg;

                log('DEBUG', `Control Confirmation: ${JSON.stringify(response)}`);

                callback(null, response);
            });
            break;
        }
        case 'TurnOff': {
            turnTVOff(request, applianceId).then((successMsg, error) => {

                if (error)
                    response = error;
                else
                    response = successMsg;

                log('DEBUG', `Control Confirmation: ${JSON.stringify(response)}`);

                callback(null, response);
            });

            break;
        }
        default: {
            log('ERROR', `No supported directive event name: ${request.header.name}`);
            callback(null, generateResponse(request, 'UnsupportedOperationError', {}, {}));
            return;
        }
    }
}

/**
 * Main entry point.
 * Incoming events from Alexa service through Smart Home API are all handled by this function.
 *
 * It is recommended to validate the request and response with Alexa Smart Home Skill API Validation package.
 *  https://github.com/alexa/alexa-smarthome-validation
 */
exports.handler = (request, context, callback) => {
    console.log(request);

    switch (request.directive.header.namespace) {
        case 'Alexa.Authorization':
            handleAuth(request.directive, callback);
            break;
         /**
         * The namespace of 'Alexa.Discovery' indicates a request is being made to the Lambda for
         * discovering all appliances associated with the customer's appliance cloud account.
         *
         * For more information on device discovery, please see
         *  https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/smart-home-skill-api-reference#discovery-messages
         */
        case 'Alexa.Discovery':
            handleDiscovery(request.directive, callback);
            break;

        case 'Alexa.PowerController':
            handlePowerControl(request.directive, callback);
            break;

        /**
         * Received an unexpected message
         */
        default: {
            const errorMessage = `No supported namespace: ${request.directive.header.namespace}`;
            log('ERROR', errorMessage);
            callback(new Error(errorMessage));
        }
    }
};