Beta testing Alexa Skills

Per sviluppare Alexa Skills puo' essere necessario un programma di beta testing. Cio' e' possibile con l'unica (e non banale) limitazione che tutti i beta tester siano registrati come developer presso Amazon

Per permettere ad altri sviluppare a fare da beta tester si puo' usare questo metodo

https://developer.amazon.com/it/blogs/post/Tx2EN8P2AHAHO6Y/How-to-Add-Beta-Testers-to-Your-Skills-Before-You-Publish

anche se non e' attualmente funzionante in Italia sembra che nel futuro il beta testing seguira' invece la procedura indicata da questo link

https://developer.amazon.com/it/blogs/alexa/post/42e7de5c-f7ef-4e3e-8391-c61fe24f6caa/improve-skill-quality-with-the-new-beta-testing-tool-for-alexa-skills-beta

Persistenza delle variabili in Alexa Skills

La persistenza delle variabili in Alexa Skills con NodeJS si ottiene tramite PersistantAttributes che si appoggia su DynamoDB in modo trasparente

In questa prima fase viene settata una variabile (per semplicita' statica) in modo persistente. Se non e' settata crea una nuova stringa. Importante impostare la chiamata come asincrona

Da notare che le variabili sono relative ad un determinato account per cui ogni utente ritrovera' le proprie impostazioni

---------------------------------------------------------------------------
const LaunchRequestHandler = {
  canHandle(handlerInput) {
     return handlerInput.requestEnvelope.request.type === 'LaunchRequest';
    
  },
  
  async handle(handlerInput) {    
    const attributesManager = handlerInput.attributesManager;
    var speechText = "Benvenuto nella skill ";

    const attributes = await attributesManager.getPersistentAttributes() || {};

    if (Object.keys(attributes).length === 0) {
      attributes.nameValue = "Luca";
      attributesManager.setPersistentAttributes(attributes);
      await attributesManager.savePersistentAttributes();
    }else {
      speechText = "Benvenuto  ${attributes.nameValue.toString()}";
    }
    
    return handlerInput.responseBuilder
      .speak(speechText)
      .withShouldEndSession(false)
      .getResponse();
  },
};
---------------------------------------------------------------------------


Con questo codice si puo' richiamare il valore della variabile da altra intent

---------------------------------------------------------------------------
 const attributesManager = handlerInput.attributesManager;
  const attributes = await attributesManager.getPersistentAttributes()
  var speechOutput =  attributes.nameValue.toString();
---------------------------------------------------------------------------

Per salvare i dati e' necessario impostare il nome della tabella in cui sono salvate le variabili e la possibilita' di creare in automatico la tabella ove non esista
---------------------------------------------------------------------------
const skillBuilder = Alexa.SkillBuilders.standard();

exports.handler = skillBuilder
  .addRequestHandlers(
    LaunchRequestHandler,
    YesHandler,
    geo,
    HelpHandler,
    ExitHandler,
    SessionEndedRequestHandler
  )
  .addErrorHandlers(ErrorHandler)
  .withTableName('alexa-data')
  .withAutoCreateTable(true)
  .lambda();
---------------------------------------------------------------------------

Sviluppare Alexa Skills: Echo od emulatore??

Questa e' una cosa che ho imparato a spese mie: gli emulatori di Alexa, anche quello ufficiale di Amazon, non hanno lo stesso comportamento e funzionalita' dei dispositivi Echo

Per esempio gli emulatori hanno problemi sono le skills di flash briefing od con il reprompt
Quando si sviluppa e' quindi sempre meglio utilizzare un dispositivo Echo reale in modo da non perdere la testa pensando di aver fatto un errore nel codice di una skill quando invece il problema e' il dispositivo

Alexa Skills: Reprompt e YesNoIntent

Per avere una maggiore interazione utente Alexa puo' terminare la propria frase con una domanda e rimanere in attesa di una risposta da parte dell'utente

Questa fase e' gestita tramite la direttiva reprompt e si possono usare le BuildIntents Yes e No quando e' sufficiente che l'utente interagisca in modo affermativo o negativo

Per esempio partendo da un custom intent si puo' aggiungere il reprompt
===========================================

const geo = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return (request.type === 'IntentRequest'
        && request.intent.name === 'geo');
  },
  
  
  async handle(handlerInput) {
  const response = await httpGet();
  //console.log("Risposta "+response);

  const { intent } = handlerInput.requestEnvelope.request;
  const activity = intent.slots.luogo.value;
  var speechOutput = response;
  
  
  if (activity == "firenze")
      {
        speechOutput = "_______________";
        //console.log("Speechout firenze"+ speechOutput+data);
      }
  
  if (activity == "milano")
      {
        speechOutput = "_______________";
      }
  
    console.log(activity);

    return handlerInput.responseBuilder
      .speak(speechOutput)
      .reprompt("Vuoi la spiegazione del messaggio?")
      .getResponse();
      
  },
};

===========================================

Si aggiunge quindi il buildinten Yes

-------------------------------------------------

                {
                    "name": "AMAZON.YesIntent",
                    "samples": []
                }

-------------------------------------------------

a questo punto per gestire la eventuale risposta positiva si aggiunge alla lambda

--------------------------------------------------

const YesHandler = {

  canHandle(handlerInput) {

    const request = handlerInput.requestEnvelope.request;

    return request.type === 'IntentRequest'

      && request.intent.name === 'AMAZON.YesIntent'

  },

  handle(handlerInput) {

    return handlerInput.responseBuilder

      .speak("Speigazione")

      .getResponse();

  },

};

--------------------------------------------------

si deve infine aggiungere lo YesHandler 

---------------------------------------------------

const skillBuilder = Alexa.SkillBuilders.standard();

exports.handler = skillBuilder

  .addRequestHandlers(

    LaunchRequestHandler,

    YesHandler,

    geo,

    HelpHandler,

    ExitHandler,

    SessionEndedRequestHandler

  )

  .addErrorHandlers(ErrorHandler)

  .lambda();

  

Interagire con DynamoDB con Lambda e API Gateway

Un sistema per interagire con DynamoDB mediante una funzione Lambda triggerata da API Gateway

Prima prima cosa ho creato a mano una tabella in DynamoDB con due colonne nome (stringa) ed indice (numerico)

La funzione Lambda per interagire con DynamoDB necessita di permessi. Per rendere le cose piu' semplici ho usato i permessi piu' estesi che corrispondono al ruolo AmazonDyamoDBFullAccess (per creare il ruolo si va in consolle di AWS, si apre IAM, Ruolo, Crea Ruolo, si selezione il servizio Lambda e si spunta AmazonDyamoDBFullAccess) Dopo aver salvato il ruolo con un nome si modifica il Ruolo di Esecuzione nella finestra della funzione Lambda impostando il nuovo ruolo

La funzione Lambda di seguito mostra un insertItem ed un getItem condizionato al valore dell'indice numerico

================================================
var AWS = require('aws-sdk');
var DOC = require('dynamodb-doc');
var dynamo = new DOC.DynamoDB();

exports.handler = function(event, context) {
  
  var tableName = "bollettini";
var item = {
    nome: "Federico",
    indice: Number(4)
}
var params = {
    TableName: tableName,
    Item: item
};


    dynamo.putItem(params, function (err, data) {
        if (err) console.log(err, err.stack); // an error occurred
        else console.log(data);               // successful response
    });
  
  var cb = function(err, data) {
    if(err) {
      console.log('error getItem: ',err);
      context.done('Unable to getItem', null);
    } else {
      if(data.Item && data.Item.nome) {
        context.done(null, data.Item);
      } else {
        context.done(null, {});
      }
    }
  };
  dynamo.getItem({TableName:"bollettini", Key:{indice:2}}, cb);

};

================================================

A questo punto per eseguire la Lambda e' necessario impostare un trigger che nel mio caso e' API Gateway. Dalla consolle di AWS si sceglie API Gateway, si selezione Create API, si indica il nome, Nella pagina successiva si clicca sul menu' a tendina Actions e si sceglie GET. Si apre una pagina sulla destra in si inserisce  l'ARN della Lambda e si salva. A questo punto si pubblica la API e si avra' come risposta un link del tipo https:/xxxxxxxx.execute-api.eu-west-1.amazonaws.com/test/

Puntano il browser al link indicato si mettera' in esecuzione la funzione Lambda

DynamoDB su localhost

Per configurare DynamoDB in localhost si devono seguire un serie di passi

1) Si deve installare AWS Cli tramite pip install awscli

2) Si deve lanciare il comando aws configure per vedere se e' stata impostata la region (di solito e' su None). Nel mio caso ho impostato eu-west-1

3) da questo link si scarica la versione locale di DynamoDB. Si scompatta e si lancia il comando (viene aperto un server in ascolto sulla porta 8000, se la porta e' occupata si possono modificare le impostazioni)

java -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar

4) a questo punto si apre un altro terminale si puo' iniziare ad interagire con DynamoDB per esempio con

aws dynamodb list-tables --endpoint-url http://localhost:8000

puo'essere necessario indicare la region usando aws configure

per creare una tabella (esempi da questo link)

Attenzione : se si lavora in locale si deve sempre utilizzare lo switch --endpoint-url http://localhost:8000 ed aggiungerlo ai comandi sottostanti

aws dynamodb create-table \ --table-name Music \ --attribute-definitions \ AttributeName=Artist,AttributeType=S \ AttributeName=SongTitle,AttributeType=S \ --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \ --provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1

e per inserire una riga

aws dynamodb put-item \ --table-name Music \ --item \ '{"Artist": {"S": "No One You Know"}, "SongTitle": {"S": "Call Me Today"}, "AlbumTitle": {"S": "Somewhat Famous"}}' \ --return-consumed-capacity TOTAL

UserId su Alexa Skills

Non ho trovato da solo il modo di richiedere ad Alexa l'identificativo dell'utente che utilizza la skill (serve per poi fornire risposte personalizzate basate su DB)...e' venuto incontro il forum
https://forums.developer.amazon.com/questions/193367/userid-alexa.html

la soluzione e' 

const userId = handlerInput.requestEnvelope.context.System.user.userId
attenzione che l'userId mostrato non e' relativo all'account Amazon dell'utente. Ogni skill genera un proprio UserID legato all'account Amazon (quest'ultimo rimane sempre mascherato)..se uno stesso  utente usa due skill differenti gli UserId che si leggeranno da Alexa  risulteranno differenti

Alexa Flash Briefing Skill

Un modo rapido di creare una Alexa Skill e' quella di utilizzare un feed RSS mediante la Flash Briefing. Di fatto non e' necessaria nessuna programmazione di un backend lambda ma e' sufficiente creare un file RSS di un certo formato su un sito disponibile in HTTPS ed indicare il link

il feed puo' essere testuale (quindi letto dalla voce di Alexa) oppure un audio MP3

--------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0">
  <channel>
    <ttl>30</ttl>
    <item>
      <guid>urn:uuid:1335c695-cfb8-4ebb-abbd-80da344efa6b</guid>
      <title>Prova di riunione veloce</title>
      <description>
        prova di trasmissione di Luca Innocenti
      </description>
      <pubDate>2018-12-07T09:30:00.0Z</pubDate>
     </item>
  </channel>
</rss>

--------------------------------------------------------------



La cosa interessante e' che una volta che l'utente si iscrive al flash briefing non e' necessario richiamare la skill ma questa viene attivata ogni volta che vengono richieste le notizie (per esempio "Alexa dammi le notizie" fa partire SkyTG24 ma prima viene proposto il Flash Briefing)



Esiste un limite di 4000 carattere per la parte descrizione

Testing EC2 Amazon

Note dopo il primo utilizzo
1) la macchina e' visibile solo in una Region ed e' quella in cui e' stata creata. Per esempio
ieri avevo creato una macchina in  eu-west-3c (Paris) mentre oggi mi sono collegato alla console di EC2 nella Region eu-central-1 (Francoforte). La macchina era raggiungibile sia via SSH che HTTP quindi era viva, semplicemente non era visibile nella web console. E' stato sufficiente settare la giusta Regione per farla riapparire (il controllo e' in alto a destra vicino all'account)

2) si possono creare anche piu' istanze (per esempio una Linux ed una Windows). Il problema e' che l'istanza Linux ha di base 8 Giga di spazio disco mente quella Windows 30 Giga. Se si attivano entrambe si sfora il limite di 30 Giga di spazio disco gratuito. Inoltre il livello gratuito consente un tempo di uso di 750 ore che corrisponde ad un mese 24x7. Se si usano due macchine il tempo si dimezza..si possono tenere accese in contemporanea solo per 15 giorni senza pagare.


-------------------------------------------------------------------------------

Questi sono i passi per configurare la propria macchina ..non tutte le opzioni (AMI = Amazon Machine Image) sono comprese per la prova gratuita. Io sono partito con una Red Hat Enterprise 7.4.
L'istanza di base e' una t2.micro

Il passo 2 e' obbligato perche' c'e' una sola scelta per il livello gratuito

la macchina viene configurata con tutte le porte chiuse. Si deve quindi abilitare esplicitamente la porta 22 per l'amministrazione SSH

La dimensione di default del disco e' di 10 Gb

Per collegarsi in SSH non viene usato usato il sistema user/pass ma la chiave privata. Si deve quindi creare una coppia di chiavi e scaricarla sul proprio client

alla fine si lancia l'istanza per far partire la macchina

Dalla consolle di amministrazione di EC2 si puo' vedere lo stato della macchina, il suo indirizzo DNS pubblico, il suo IP

queste informazioni sono necessarie per collegarsi in SSH
Da Linux e Mac la sintassi e' la seguente (AmazonEC2.pem e' il nome del file della mia chiave, ec2-user e' l'utente di default sulle macchine RedHat, alla fine si mette il nome DNS pubblico o l'indirizzo pubblico)
Attenzione : si devono modificare i permessi del file .pem con chmod 400 AmazonEC2.pem

ssh -i AmazonEC2.pem ec2-user@xxxxxxxxxx.eu-west-3.compute.amazonaws.com

i comandi di root sono eseguiti usando sempre sudo. Una curiosita'...non c'e' la history sulla linea di comando di bash

Per la connessione con SFTP si puo' usare Filezilla impostandolo con l'accesso tramite File Chiave

Per connettersi in SSH da Putty si deve convertire la chiave in formato .pem in formato .ppk utilizzando PuttyGen e Load il file .pem e Save Private Key.
Il file nuovamente generato si inserisce in Connection\Auth e poi si stabilisce la connessione come di norma mettendo nell'host la combinazione ec2-user@xxxxxxxxxx.eu-west-3.compute.amazonaws.com

A questo punto si procede con la configurazione come di norma

sudo yum update

sudo yum install httpd

sudo apachectl start

sudo apachectl status

* httpd.service - The Apache HTTP Server

   Loaded: loaded (/usr/lib/systemd/system/httpd.service; enabled; vendor preset: disabled)

   Active: active (running) since Thu 2018-03-08 16:52:51 UTC; 57s ago

     Docs: man:httpd(8)

           man:apachectl(8)

 Main PID: 3406 (httpd)

   Status: "Total requests: 0; Current requests/sec: 0; Current traffic:   0 B/sec"

   CGroup: /system.slice/httpd.service

           |-3406 /usr/sbin/httpd -DFOREGROUND

           |-3407 /usr/sbin/httpd -DFOREGROUND

           |-3408 /usr/sbin/httpd -DFOREGROUND

           |-3409 /usr/sbin/httpd -DFOREGROUND

           |-3410 /usr/sbin/httpd -DFOREGROUND

           `-3411 /usr/sbin/httpd -DFOREGROUND

Una volta installato ed avviato il server http si deve aprire la porta 80 per l'accesso dall'esterno

ed alla fine il server httpd e' raggiungibile dall'esterno

per finire si deve rendere scrivibile dall'utente la directory del webserver per le modifiche

sudo usermod -a -G apache ec2-user
sudo chown -R ec2-user:apache /var/www
sudo chmod 2775 /var/www
find /var/www -type d -exec sudo chmod 2775 {} \;
find /var/www -type f -exec sudo chmod 0664 {} \;

attenzione : di default non e' abilitato il supporto https

Dentro ad Amazon Fire

La bambina e' riuscita, facendo cadere di piatto lato schermo il tablet per terra, ad aprirlo in un colpo solo

Una occasione per vedere come e' fatto dentro. Curiosa la posizione dello speaker (mono)
PS: il tablet e' sopravvissuto...e' decisamente resistente

Amazon Button Tear Down

E' da pochi giorni disponibile in Italia per l'acquisto l'Amazon Button, un dispositivo che permette (in pieno stile IoT) di effettuare acquisti su Amazon con la sola pressione di un tasto.
Grazie all'amico G.S. e' tempo di procedere allo smontaggio

il dispositivo e' facilmente accessibile tramite viti (TORX) e connessioni a scatto e presenta una comoda con alimentazione a batteria di tipo AAA

Quella che e' venduta in Italia risulta essere la revisione 2 della scheda che si differenzia di molto rispetto alla Rev.1 commercializzata negli USA gia' da piu' di un anno (e per la quale esistono gia' molti hack per prendere possesso del dispositivo)

Un primo aspetto importante: rispetto alla versione 1, sulla quale era possibile saldare dei connettori di programmazione per il JTAG, in questa PCB ci sono i punti di saldatura ma non e' presente il chip di programmazione ed interfaccia.

E' presente una connettivita' sia WiFi che BT4

I chip che sono montati, in particolare il microprocessore, sono di particolare interesse
Microcontrollore : Atmel ATSAMG55J19A-MU
 WiFi : Atmel ATWINC1500B
 BT : Cypress CYBL10563-68FNXI

Considerando il tipo di utilizzo il microcontrollore e' un mostro da 120 MHz con SPI, I2C, 8 canali analogici  con ADC a 12 bit