Add basic classes

Author: dolanmiu

src/connection.ts

@@ -1,29 +1,16 @@
 // https://developer.amazon.com/docs/alexa-voice-service/manage-http2-connection.html
-import * as https from "https";
-import * as spdy from "spdy";
+import * as http2 from "http2";
+import {API_VERSION} from "./constants/general";
 
 export default class Connection {
-    constructor(private readonly agent: spdy.Agent, private readonly endpoint: string) {}
+    constructor(private readonly client: http2.ClientHttp2Session) {}
 
     public connect(accessToken: string): void {
-        const req = https.get(
-            {
-                host: `${this.endpoint}/directives`,
-                agent: this.agent,
-                headers: {
-                    authorization: `Bearer ${accessToken}`,
-                },
-            },
-            (response) => {
-                // TODO
-            },
-        );
-
-        req.on("push", (stream) => {
-            stream.on("error", (err) => {
-                // Handle error
-            });
-            // Read data from stream
+        const req = this.client.request({
+            ":path": `/${API_VERSION}/directives`,
+            authorization: `Bearer ${accessToken}`,
         });
+
+        req.end();
     }
 }

src/constants/general.ts

@@ -1 +1,2 @@
 export const API_VERSION = "v20160207";
+export const HTTP2_BOUNDARY = "this-is-a-boundary";

src/http2-utility.ts

@@ -0,0 +1,16 @@
+import {HTTP2_BOUNDARY} from "./constants/general";
+
+export default class Http2Utility {
+    public createMetadata<T>(body: T): string {
+        const output = `--${HTTP2_BOUNDARY}
+        Content-Disposition: form-data; name="metadata"
+        Content-Type: application/json; charset=UTF-8
+
+        ${JSON.stringify(body)}
+
+        --HTTP2_BOUNDARY--
+        `;
+
+        return output;
+    }
+}

src/index.ts

@@ -1,18 +1,22 @@
-import * as https from "https";
-import * as spdy from "spdy";
+import * as http2 from "http2";
+
+import Connection from "./connection";
+import {BASE_URLS} from "./constants/base-urls";
+import {API_VERSION} from "./constants/general";
 import SpeechRecognizer from "./speech-recognizer";
+import System from "./system";
+
+const client = http2.connect(`${BASE_URLS.europe}`);
+client.on("error", (err) => console.error(err));
+client.on("socketError", (err) => console.error(err));
+
+const context: AVS.Context = [];
 
-const agent = spdy.createAgent({
-    host: "www.google.com",
-    port: 443,
+const speechSynthesizer = new SpeechRecognizer(client);
+const connection = new Connection(client);
+const system = new System(client);
 
-    // Optional SPDY options
-    spdy: {
-        plain: false,
-        ssl: true,
-        // **optional** send X_FORWARDED_FOR
-        "x-forwarded-for": "127.0.0.1",
-    },
-});
+const accessToken = "";
 
-const s = new SpeechRecognizer(agent);
+connection.connect(accessToken);
+system.synchronizeState(accessToken, context);

src/speech-recognizer.ts

@@ -1,26 +1,10 @@
 // https://developer.amazon.com/docs/alexa-voice-service/speechrecognizer.html
-import * as https from "https";
-import * as spdy from "spdy";
+import * as http2 from "http2";
 
 export default class SpeechRecognizer {
-    constructor(private agent: spdy.Agent) {}
+    constructor(private readonly client: http2.ClientHttp2Session) {}
 
     public fire(): void {
-        const req = https.get(
-            {
-                host: "https://avs-alexa-eu.amazon.com",
-                agent: this.agent,
-            },
-            (response) => {
-                // TODO
-            },
-        );
-
-        req.on("push", (stream) => {
-            stream.on("error", (err) => {
-                // Handle error
-            });
-            // Read data from stream
-        });
+        // Todo
     }
 }

src/system.ts

@@ -1,3 +1,58 @@
 // https://developer.amazon.com/docs/alexa-voice-service/system.html
+import * as http2 from "http2";
 
-export default class System {}
+import {API_VERSION, HTTP2_BOUNDARY} from "./constants/general";
+import Http2Utility from "./http2-utility";
+
+export default class System {
+    private readonly http2Utility: Http2Utility;
+
+    constructor(private readonly client: http2.ClientHttp2Session) {
+        this.http2Utility = new Http2Utility();
+    }
+
+    public synchronizeState(accessToken: string, context: AVS.Context): void {
+        const req = this.client.request({
+            ":method": "POST",
+            ":path": `/${API_VERSION}/events`,
+            authorization: `Bearer ${accessToken}`,
+            "content-type": `multipart/form-data; boundary=${HTTP2_BOUNDARY}`,
+        });
+
+        console.log("okie");
+
+        // req.on("response", (headers, flags) => {
+        //     for (const name in headers) {
+        //         console.log(`${name}: ${headers[name]}`);
+        //     }
+        // });
+
+        const f = this.http2Utility.createMetadata({
+            context: context,
+            event: {
+                header: {
+                    namespace: "System",
+                    name: "SynchronizeState",
+                    messageId: "test",
+                },
+                payload: {},
+            },
+        });
+
+        req.write(f, () => {
+            console.log("dun knoe");
+            console.log();
+        });
+
+        req.setEncoding("utf8");
+        let data = "";
+        req.on("data", (chunk) => {
+            data += chunk;
+        });
+        req.on("end", () => {
+            console.log(`\n${data}`);
+            // client.close();
+        });
+        req.end();
+    }
+}