adds sample application for Archiving

Author: aoberoi

sample/Archiving/build.gradle

@@ -0,0 +1,16 @@
+apply plugin:'application'
+mainClassName = "com.example.ArchivingServer"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile project(':')
+    compile group: 'com.github.codingricky', name: 'spark-core-16', version: '1.1'
+    compile group: 'org.freemarker', name: 'freemarker', version: '2.3.19'
+    compile group: 'org.slf4j', name: 'slf4j-simple', version: '1.7.6'
+}
+
+run.systemProperty 'API_KEY', '854511'
+run.systemProperty 'API_SECRET', '***REMOVED***'

sample/Archiving/public/css/sample.css

@@ -0,0 +1,22 @@
+/* Move down content because we have a fixed navbar that is 50px tall */
+body {
+  padding-top: 50px;
+  padding-bottom: 20px;
+  background-color: #F2F2F2;
+}
+
+/* Responsive: Portrait tablets and up */
+@media screen and (min-width: 768px) {
+  /* Remove padding from wrapping element since we kick in the grid classes here */
+  .body-content {
+    padding: 0;
+  }
+}
+
+#subscribers div {
+  float: left;
+}
+
+.bump-me {
+  padding-top: 40px;
+}

sample/Archiving/public/img/archiving-off.png

@@ -0,0 +1,32 @@
+// Initialize an OpenTok Session object
+var session = TB.initSession(sessionId);
+
+// Initialize a Publisher, and place it into the element with id="publisher"
+var publisher = TB.initPublisher(apiKey, 'publisher');
+
+// Attach event handlers
+session.on({
+
+  // This function runs when session.connect() asynchronously completes
+  sessionConnected: function(event) {
+    // Publish the publisher we initialzed earlier (this will trigger 'streamCreated' on other
+    // clients)
+    session.publish(publisher);
+  },
+
+  // This function runs when another client publishes a stream (eg. session.publish())
+  streamCreated: function(event) {
+    // Create a container for a new Subscriber, assign it an id using the streamId, put it inside
+    // the element with id="subscribers"
+    var subContainer = document.createElement('div');
+    subContainer.id = 'stream-' + event.stream.streamId;
+    document.getElementById('subscribers').appendChild(subContainer);
+
+    // Subscribe to the stream that caused this event, put it inside the container we just made
+    session.subscribe(event.stream, subContainer);
+  }
+
+});
+
+// Connect to the Session using the 'apiKey' of the application and a 'token' for permission
+session.connect(apiKey, token);

sample/Archiving/public/img/archiving-on-idle.png

@@ -0,0 +1,37 @@
+var session = OT.initSession(sessionId),
+    publisher = OT.initPublisher("publisher"),
+    archiveID = null;
+
+session.connect(apiKey, token, function(err, info) {
+  if(err) {
+    alert(err.message || err);
+  }
+  session.publish(publisher);
+});
+
+session.on('streamCreated', function(event) {
+  session.subscribe(event.stream, "subscribers", { insertMode: "append" });
+});
+
+session.on('archiveStarted', function(event) {
+  archiveID = event.id;
+  console.log("ARCHIVE STARTED");
+  $(".start").hide();
+  $(".stop").show();
+});
+
+session.on('archiveStopped', function(event) {
+  archiveID = null;
+  console.log("ARCHIVE STOPPED");
+  $(".start").show();
+  $(".stop").hide();
+});
+
+$(document).ready(function() {
+  $(".start").click(function(event){
+    $.get("start");
+  }).show();
+  $(".stop").click(function(event){
+    $.get("stop/" + archiveID);
+  }).hide();
+});

sample/Archiving/public/img/archiving-on-message.png

@@ -0,0 +1,13 @@
+var session = OT.initSession(sessionId),
+    publisher = OT.initPublisher("publisher");
+
+session.connect(apiKey, token, function(err, info) {
+  if(err) {
+    alert(err.message || err);
+  }
+  session.publish(publisher);
+});
+
+session.on('streamCreated', function(event) {
+  session.subscribe(event.stream, "subscribers", { insertMode : "append" });
+});

sample/Archiving/public/js/helloworld.js

@@ -0,0 +1,186 @@
+package com.example;
+
+import static spark.Spark.*;
+
+import com.opentok.*;
+import com.opentok.OpenTok;
+import com.opentok.Role;
+import com.opentok.TokenOptions;
+import com.opentok.Archive;
+import spark.*;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+
+import com.opentok.exception.OpenTokException;
+
+public class ArchivingServer {
+
+    private static final String apiKey = System.getProperty("API_KEY");
+    private static final String apiSecret = System.getProperty("API_SECRET");
+    private static final OpenTok opentok = new OpenTok(Integer.parseInt(apiKey), apiSecret);
+    private static String sessionId;
+
+    public static void main(String[] args) throws OpenTokException {
+
+        if (apiKey == null || apiKey.isEmpty() || apiSecret == null || apiSecret.isEmpty()) {
+            System.out.println("You must define API_KEY and API_SECRET system properties in the build.gradle file.");
+            System.exit(-1);
+        }
+
+        sessionId = opentok.createSession().getSessionId();
+
+        externalStaticFileLocation("./public");
+
+        get(new FreeMarkerTemplateView("/") {
+            @Override
+            public ModelAndView handle(Request request, Response response) {
+                //Map<String, Object> attributes = new HashMap<String, Object>();
+                return new ModelAndView(null, "index.ftl");
+            }
+        });
+
+        get(new FreeMarkerTemplateView("/host") {
+            @Override
+            public ModelAndView handle(Request request, Response response) {
+
+                String token = null;
+                try {
+                    token = opentok.generateToken(sessionId, new TokenOptions.Builder()
+                        .role(Role.MODERATOR)
+                        .build());
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                }
+
+                Map<String, Object> attributes = new HashMap<String, Object>();
+                attributes.put("apiKey", apiKey);
+                attributes.put("sessionId", sessionId);
+                attributes.put("token", token);
+
+                return new ModelAndView(attributes, "host.ftl");
+            }
+        });
+
+        get(new FreeMarkerTemplateView("/participant") {
+            @Override
+            public ModelAndView handle(Request request, Response response) {
+
+                String token = null;
+                try {
+                    token = opentok.generateToken(sessionId, new TokenOptions.Builder()
+                            .role(Role.MODERATOR)
+                            .build());
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                }
+
+                Map<String, Object> attributes = new HashMap<String, Object>();
+                attributes.put("apiKey", apiKey);
+                attributes.put("sessionId", sessionId);
+                attributes.put("token", token);
+
+                return new ModelAndView(attributes, "participant.ftl");
+            }
+        });
+
+        get(new FreeMarkerTemplateView("/history") {
+            @Override
+            public ModelAndView handle(Request request, Response response) {
+
+                String pageParam = request.queryParams("page");
+                int page;
+                try {
+                    page = Integer.parseInt(pageParam);
+                } catch (NumberFormatException e) {
+                    page = 1;
+                }
+
+                int offset = (page - 1) * 5;
+                List<Archive> archives = null;
+                try {
+                    archives = opentok.listArchives(offset, 5);
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                }
+
+                Map<String, Object> attributes = new HashMap<String, Object>();
+                attributes.put("archives", archives);
+                attributes.put("showPrevious", null);
+                // TODO: we don't have a total count, how do we know if there is a next page?
+                attributes.put("showNext", "/history?page=" + (page + 1));
+
+                if (page > 1) {
+                    attributes.put("showPrevious", "/history?page=" + (page - 1));
+                }
+
+                return new ModelAndView(attributes, "history.ftl");
+            }
+        });
+
+        get(new Route("/download/:archiveId") {
+            @Override
+            public Object handle(Request request, Response response) {
+
+                Archive archive = null;
+                try {
+                    archive = opentok.getArchive(request.params("archiveId"));
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                    return null;
+                }
+
+                response.redirect(archive.getUrl());
+                return null;
+            }
+        });
+
+        get(new Route("/start") {
+            @Override
+            public Object handle(Request request, Response response) {
+
+                Archive archive = null;
+                try {
+                    archive = opentok.startArchive(sessionId, "Java Archiving Sample App");
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                    return null;
+                }
+                return archive.toString();
+            }
+        });
+
+        get(new Route("/stop/:archiveId") {
+            @Override
+            public Object handle(Request request, Response response) {
+
+                Archive archive = null;
+                try {
+                    archive = opentok.stopArchive(request.params("archiveId"));
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                    return null;
+                }
+                return archive.toString();
+            }
+        });
+
+        get(new Route("/delete/:archiveId") {
+            @Override
+            public Object handle(Request request, Response response) {
+
+                try {
+                    opentok.deleteArchive(request.params("archiveId"));
+                } catch (OpenTokException e) {
+                    e.printStackTrace();
+                    return null;
+                }
+                response.redirect("/history");
+                return null;
+            }
+        });
+
+
+    }
+}

sample/Archiving/public/js/host.js

@@ -0,0 +1,49 @@
+package com.example;
+
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+import freemarker.template.TemplateException;
+import spark.ModelAndView;
+import spark.TemplateViewRoute;
+
+import java.io.IOException;
+import java.io.StringWriter;
+
+public abstract class FreeMarkerTemplateView extends TemplateViewRoute {
+
+    private Configuration configuration;
+
+    protected FreeMarkerTemplateView(String path) {
+        super(path);
+        this.configuration = createFreemarkerConfiguration();
+    }
+
+    protected FreeMarkerTemplateView(String path, String acceptType) {
+        super(path, acceptType);
+        this.configuration = createFreemarkerConfiguration();
+    }
+
+    @Override
+    public String render(ModelAndView modelAndView) {
+        try {
+            StringWriter stringWriter = new StringWriter();
+
+            Template template = configuration.getTemplate(modelAndView.getViewName());
+            template.process(modelAndView.getModel(), stringWriter);
+
+            return stringWriter.toString();
+
+        } catch (IOException e) {
+            throw new IllegalArgumentException(e);
+        } catch (TemplateException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+
+    private Configuration createFreemarkerConfiguration() {
+        Configuration retVal = new Configuration();
+        retVal.setClassForTemplateLoading(FreeMarkerTemplateView.class, "freemarker");
+        return retVal;
+    }
+
+}