Created July 8, 2016

Alexa skill: Photographer

Learn various photographer's terminology by just asking Alexa about it.

BeginnerProtip1 hour252

Runner Up!

The Internet of Voice Challenge

Things used in this project

Software apps and online services

Amazon Web Services AWS Lambda

Amazon Alexa Alexa Skills Kit

Story

Overview

As a photographer, you have to know various terms used in the photography. Sometimes it gets really overwhelming to know each and every term and what does it mean, especially, when you are an amateur.

That's why I decide to write a skill for Alexa. So, the next time I want to know any term, I'll just ask Alexa.

Here is the link to the published skill.

Let's get into the detail of writing the skill.

Step1: Define your skill

Complete the Skill Information Page.

Application Id: The ID for this skill

(Non-editable, but this is your this is your generated application ID)

Skill Type (Required)

You can choose a Skill API or define the interaction model.

Custom Interaction Model

Smart Home Skill API

For this project we are using "Custom Interaction Model"

Name (Required)

The name of this skill. This is the name displayed in the Alexa App.

Invocation Name (Required)

The name users will say to interact with this skill. This does not have to be the same as the skill name. The invocation name must comply with the Invocation Name Guidelines

Step 2: Define your Interaction model

Complete the Interaction Model Page.

Intent Schema (Required)

The schema of user intents in JSON format. For more information, see Intent Schema.

Also see built-in slots and built-in intents.

Scroll down to the code section to see the Intent schema for this skill.

Sample Utterances (Required)

Phrases end users say to interact with the skill. For better results, provide as many samples as you can.

Note that you must select three of these to use as your Example Phrases on the Description tab.

Scroll down to the code section to see the Sample utterances for this skill.

Step 3: Configuration

Endpoint (Required)

Lambda ARN url for Smart Home Adapter.

More info about AWS Lambda

How to integrate AWS Lambda with Alexa

Here is where you map the web service that drives the back end interaction with the Alexa Skill. Here is where you point you skill at that service will describe in code section. You can map it to your own hosted service or a service you construct in AWS Lambda.

Account Linking

Do you allow users to create an account or link to an existing account with you?Learn more

We are not using Account Linking in this project.

Step 4: Testing

This is where you test your service. You can past your Utterances in the "Enter Utterance" field and click the "Ask Your Service Name" button to test the interaction.

You will see the formatted Lambda Request and Lambda Response in the boxes below.

Step 5: Publish

Here is where you get really creative... You describe what your Skill will do in both short and long form for display in the Skills directory. Also specify so example Utterances, Icons, Keywords and Testing Instructions for the Certification process.

Step 6. Privacy & Compliance

Complete the privacy questionnaire regarding if the Skill requires purchases or the exchange of money. If personal information is collected. You can also link any Privacy statements or Terms of Use URLS.

Step 7. Submission

When you are tested and ready to go, submit your Skill for certification. Note: once you submit it, you can no longer edit or test the service.

/**
    Copyright 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.

    Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at

        http://aws.amazon.com/apache2.0/

    or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
*/

'use strict';

function AlexaSkill(appId) {
    this._appId = appId;
}

AlexaSkill.speechOutputType = {
    PLAIN_TEXT: 'PlainText',
    SSML: 'SSML'
}

AlexaSkill.prototype.requestHandlers = {
    LaunchRequest: function (event, context, response) {
        this.eventHandlers.onLaunch.call(this, event.request, event.session, response);
    },

    IntentRequest: function (event, context, response) {
        this.eventHandlers.onIntent.call(this, event.request, event.session, response);
    },

    SessionEndedRequest: function (event, context) {
        this.eventHandlers.onSessionEnded(event.request, event.session);
        context.succeed();
    }
};

/**
 * Override any of the eventHandlers as needed
 */
AlexaSkill.prototype.eventHandlers = {
    /**
     * Called when the session starts.
     * Subclasses could have overriden this function to open any necessary resources.
     */
    onSessionStarted: function (sessionStartedRequest, session) {
    },

    /**
     * Called when the user invokes the skill without specifying what they want.
     * The subclass must override this function and provide feedback to the user.
     */
    onLaunch: function (launchRequest, session, response) {
        throw "onLaunch should be overriden by subclass";
    },

    /**
     * Called when the user specifies an intent.
     */
    onIntent: function (intentRequest, session, response) {
        var intent = intentRequest.intent,
            intentName = intentRequest.intent.name,
            intentHandler = this.intentHandlers[intentName];
        if (intentHandler) {
            console.log('dispatch intent = ' + intentName);
            intentHandler.call(this, intent, session, response);
        } else {
            throw 'Unsupported intent = ' + intentName;
        }
    },

    /**
     * Called when the user ends the session.
     * Subclasses could have overriden this function to close any open resources.
     */
    onSessionEnded: function (sessionEndedRequest, session) {
    }
};

/**
 * Subclasses should override the intentHandlers with the functions to handle specific intents.
 */
AlexaSkill.prototype.intentHandlers = {};

AlexaSkill.prototype.execute = function (event, context) {
    try {
        console.log("session applicationId: " + event.session.application.applicationId);

        // Validate that this request originated from authorized source.
        if (this._appId && event.session.application.applicationId !== this._appId) {
            console.log("The applicationIds don't match : " + event.session.application.applicationId + " and "
                + this._appId);
            throw "Invalid applicationId";
        }

        if (!event.session.attributes) {
            event.session.attributes = {};
        }

        if (event.session.new) {
            this.eventHandlers.onSessionStarted(event.request, event.session);
        }

        // Route the request to the proper handler which may have been overriden.
        var requestHandler = this.requestHandlers[event.request.type];
        requestHandler.call(this, event, context, new Response(context, event.session));
    } catch (e) {
        console.log("Unexpected exception " + e);
        context.fail(e);
    }
};

var Response = function (context, session) {
    this._context = context;
    this._session = session;
};

function createSpeechObject(optionsParam) {
    if (optionsParam && optionsParam.type === 'SSML') {
        return {
            type: optionsParam.type,
            ssml: optionsParam.speech
        };
    } else {
        return {
            type: optionsParam.type || 'PlainText',
            text: optionsParam.speech || optionsParam
        }
    }
}

Response.prototype = (function () {
    var buildSpeechletResponse = function (options) {
        var alexaResponse = {
            outputSpeech: createSpeechObject(options.output),
            shouldEndSession: options.shouldEndSession
        };
        if (options.reprompt) {
            alexaResponse.reprompt = {
                outputSpeech: createSpeechObject(options.reprompt)
            };
        }
        if (options.cardTitle && options.cardContent) {
            alexaResponse.card = {
                type: "Simple",
                title: options.cardTitle,
                content: options.cardContent
            };
        }
        var returnResult = {
                version: '1.0',
                response: alexaResponse
        };
        if (options.session && options.session.attributes) {
            returnResult.sessionAttributes = options.session.attributes;
        }
        return returnResult;
    };

    return {
        tell: function (speechOutput) {
            this._context.succeed(buildSpeechletResponse({
                session: this._session,
                output: speechOutput,
                shouldEndSession: true
            }));
        },
        tellWithCard: function (speechOutput, cardTitle, cardContent) {
            this._context.succeed(buildSpeechletResponse({
                session: this._session,
                output: speechOutput,
                cardTitle: cardTitle,
                cardContent: cardContent,
                shouldEndSession: true
            }));
        },
        ask: function (speechOutput, repromptSpeech) {
            this._context.succeed(buildSpeechletResponse({
                session: this._session,
                output: speechOutput,
                reprompt: repromptSpeech,
                shouldEndSession: false
            }));
        },
        askWithCard: function (speechOutput, repromptSpeech, cardTitle, cardContent) {
            this._context.succeed(buildSpeechletResponse({
                session: this._session,
                output: speechOutput,
                reprompt: repromptSpeech,
                cardTitle: cardTitle,
                cardContent: cardContent,
                shouldEndSession: false
            }));
        }
    };
})();

module.exports = AlexaSkill;

/**
    Copyright 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.

    Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at

        http://aws.amazon.com/apache2.0/

    or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
*/

/**
 * This sample shows how to create a Lambda function for handling Alexa Skill requests that:
 *
 * - Custom slot type: demonstrates using custom slot types to handle a finite set of known values
 *
 * Examples:
 * One-shot model:
 *  User: "Alexa, ask Minecraft Helper how to make paper."
 *  Alexa: "(reads back recipe for paper)"
 */

'use strict';

var AlexaSkill = require('./AlexaSkill'),
    recipes = require('./recipes');

var APP_ID = undefined; //replace with 'amzn1.echo-sdk-ams.app.[your-unique-value-here]';

/**
 * MinecraftHelper is a child of AlexaSkill.
 * To read more about inheritance in JavaScript, see the link below.
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript#Inheritance
 */
var MinecraftHelper = function () {
    AlexaSkill.call(this, APP_ID);
};

// Extend AlexaSkill
MinecraftHelper.prototype = Object.create(AlexaSkill.prototype);
MinecraftHelper.prototype.constructor = MinecraftHelper;

MinecraftHelper.prototype.eventHandlers.onLaunch = function (launchRequest, session, response) {
    var speechText = "Welcome to the Photographer skill. You can ask a question like, what's aperture? ... Now, what can I help you with.";
    // If the user either does not reply to the welcome message or says something that is not
    // understood, they will be prompted again with this text.
    var repromptText = "For instructions on what you can say, please say help me.";
    response.ask(speechText, repromptText);
};

MinecraftHelper.prototype.intentHandlers = {
    "RecipeIntent": function (intent, session, response) {
        var itemSlot = intent.slots.Item,
            itemName;
        if (itemSlot && itemSlot.value){
            itemName = itemSlot.value.toLowerCase();
        }

        var cardTitle = "Recipe for " + itemName,
            recipe = recipes[itemName],
            speechOutput,
            repromptOutput;
        if (recipe) {
            speechOutput = {
                speech: recipe,
                type: AlexaSkill.speechOutputType.PLAIN_TEXT
            };
            response.tellWithCard(speechOutput, cardTitle, recipe);
        } else {
            var speech;
            if (itemName) {
                speech = "I'm sorry, I currently do not know " + itemName + ". What else can I help with?";
            } else {
                speech = "I'm sorry, I currently do not know. What else can I help with?";
            }
            speechOutput = {
                speech: speech,
                type: AlexaSkill.speechOutputType.PLAIN_TEXT
            };
            repromptOutput = {
                speech: "What else can I help with?",
                type: AlexaSkill.speechOutputType.PLAIN_TEXT
            };
            response.ask(speechOutput, repromptOutput);
        }
    },

    "AMAZON.StopIntent": function (intent, session, response) {
        var speechOutput = "Goodbye";
        response.tell(speechOutput);
    },

    "AMAZON.CancelIntent": function (intent, session, response) {
        var speechOutput = "Goodbye";
        response.tell(speechOutput);
    },

    "AMAZON.HelpIntent": function (intent, session, response) {
        var speechText = "You can ask questions about Photographer's terminologies such as, what's aperture, or, you can say exit... Now, what can I help you with?";
        var repromptText = "You can say things like, what's the aperture, or you can say exit... Now, what can I help you with?";
        var speechOutput = {
            speech: speechText,
            type: AlexaSkill.speechOutputType.PLAIN_TEXT
        };
        var repromptOutput = {
            speech: repromptText,
            type: AlexaSkill.speechOutputType.PLAIN_TEXT
        };
        response.ask(speechOutput, repromptOutput);
    }
};

exports.handler = function (event, context) {
    var minecraftHelper = new MinecraftHelper();
    minecraftHelper.execute(event, context);
};

/**
    Copyright 2014-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.

    Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with the License. A copy of the License is located at

        http://aws.amazon.com/apache2.0/

    or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
*/

module.exports = {
    "Auto Exposure": "Auto Exposure is a system for automatically setting the proper exposure according to the existing light conditions.",
    "Aperture": "Aperture is the lens opening formed by the iris diaphragm inside the lens.",
    "Aperture Priority": "Exposure is calculated based on the aperture value chosen by the photographer. This allows for depth of field control. Large aperture gives shallow depth of field and a small aperture gives deep depth of field.",
    "Autofocus": "The camera lens focuses automatically, usually when the shutter release is half-pressed.",
    "Backlight": "The illumination for a colour LCD display. Early colour LCD used high voltage fluorescent lamps, newer LCDs now use white LEDs which are much more energy efficient.",
    "Bleed": "Printing term referring to an image or linked area that extends to the edge of the printed piece.",
    "Burst Mode": "The ability to rapidly capture images as long as the shutter button is held down. Also called Continuous frame capture.",
    "Chromatic Aberration": "Also known as the purple fringe effect. It is common in two Megapixel and higher resolution digital cameras (especially those with long telephoto zoom lenses) when a dark area is surrounded by a highlight. Along the edge between dark and light you will see a line or two of purple or violet coloured pixels that shouldn't be there."
    "Contrast": "A measure of rate of change of brightness in an image.",
    "Depth of Field": "Depth of field is the range of sharp focus. Controlled by the focal length and aperture opening of the lens. A large aperture yields shallow depth of field whereas smaller apertures yield deeper depth of field.",
    "Dynamic Range": "A measurement of the accuracy of an image in colour or gray level. More bits of dynamic range results in finer gradations being preserved.",
    "Exposure": "The amount of light that reaches the image sensor and is controlled by a combination of the lens aperture and shutter speed.",
    "Exposure Bracketing": "The camera automatically takes a series of 3 or 5 pictures and slightly varies the EV for each frame. This insures that at least one of the pictures will be as close to perfectly exposed as possible.",
    "Exposure Compensation": "Lighten or darken the image by overriding the exposure system.",
    "Focus Lock": "Pre-focusing the camera and then moving it to re-compose the image before capturing it. Accomplished by half-pressing the shutter button and keeping it held at that position while moving the camera to another point before pressing it all the way to capture the image.",
    "Histogram": "A bar graph analysis tool that can be used to identify contrast and dynamic range of an image.",
    "Intervalometer": "Fancy term for Time-Lapse. Capture an image or series of images at preset intervals automatically.",
    "ISO": "The speed or specific light-sensitivity of a camera is rated by ISO numbers such as 100, 400, etc. The higher the number, the more sensitive it is to light. As with film, the higher speeds usually induce more electronic noise so the image gets grainier. ISO is the abbreviation for International Standards Organisation.",
    "Metering": "Used to calculate the exposure from the existing light conditions.",
    "Overexposure": "An image that appears too light. All the highlights and colours are totally lost and usually unrecoverable even by software."
};

Credits

Shivansh Singh

6 projects • 23 followers

Comments

Awards

Runner Up!

The Internet of Voice Challenge

Alexa skill: Photographer

Things used in this project

Software apps and online services

Story

Overview

Step1: Define your skill

Step 2: Define your Interaction model

Step 3: Configuration

Step 4: Testing

Step 5: Publish

Step 6. Privacy & Compliance

Step 7. Submission

Code

AlexaSkills.js

index.js

recipe.js

Intent Schema

Sample Utterances

Credits

Shivansh Singh

Comments

Awards

Embed the widget on your own site

Alexa skill: Photographer

Alexa skill: Photographer

Things used in this project

Software apps and online services

Story

Overview

Step1: Define your skill

Step 2: Define your Interaction model

Step 3: Configuration

Step 4: Testing

Step 5: Publish

Step 6. Privacy & Compliance

Step 7. Submission

Code

AlexaSkills.js

index.js

recipe.js

Intent Schema

Sample Utterances

Credits

Shivansh Singh

Comments

Awards