Implement Indicator and IndicatorManager classes

index.js

@@ -106,7 +106,7 @@ var DumbPipe = {
     try {
       document.getElementById("mozbrowser").contentWindow.postMessage(envelope, "*");
     } catch (e) {
-      console.log("Error " + e + " while sending message: " + JSON.stringify(message));
+      console.log("Error " + e + " while sending message: " + JSON.stringify(envelope));
     }
   },
 
@@ -421,3 +421,56 @@ DumbPipe.registerOpener("camera", function(message, sender) {
     }
   };
 });
+
+var notification = null;
+DumbPipe.registerOpener("notification", function(message, sender) {
+  if (notification) {
+    notification.close();
+    notification = null;
+  }
+
+  var img = new Image();
+  img.src = URL.createObjectURL(new Blob([ new Uint8Array(message.icon) ], { type : message.mime_type }));
+  img.onload = function() {
+    var width = Math.min(32, img.naturalWidth);
+    var height = Math.min(32, img.naturalHeight);
+
+    var canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    var ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0, width, height);
+
+    message.options.icon = canvas.toDataURL();
+
+    function permissionGranted() {
+      notification = new Notification(message.title, message.options);
+      notification.onshow = function() {
+        sender({ type: "opened" });
+      };
+    }
+
+    if (Notification.permission === "granted") {
+      permissionGranted();
+    } else if (Notification.permission !== 'denied') {
+      Notification.requestPermission(function(permission) {
+        if (permission === "granted") {
+          permissionGranted();
+        }
+      });
+    }
+  }
+
+  return function(message) {
+    switch(message.type) {
+      case "close":
+        if (notification) {
+          notification.close();
+          notification = null;
+        }
+
+        sender({ type: "close" });
+      break;
+    }
+  }
+});

java/custom/com/nokia/mid/s40/codec/DataEncoder.java

@@ -23,7 +23,5 @@ public DataEncoder(String name) throws IOException {
 
     public native void put(int tag, String name, double value) throws IOException;
 
-    public void put(String aString, byte[] aArray, int aInt) throws IOException {
-        throw new RuntimeException("DataEncoder::put(String,byte[],int) not implemented");
-    }
+    public native void put(String name, byte[] data, int length) throws IOException;
 }

java/custom/com/nokia/mid/ui/lcdui/Indicator.java

@@ -2,16 +2,36 @@
 
 import javax.microedition.lcdui.Image;
 
+/*
+ * This class is undocumented.
+ *
+ * We're implementing indicators using the Notifications API.
+ * When setActive is called with true, we enable showing notifications.
+ * When setActive is called with false, we dismiss notifications.
+ * This class is associated with the nokia.active-standby localmsg
+ * server, that gives us the text associated with the Indicator.
+ * We show a notification when the nokia.active-standby receives an
+ * "Update" event and the Indicator is active.
+ *
+ * We're storing an icon in the image property, but we're not really
+ * using it (we're using the icon sent to the nokia.active-standby
+ * server).
+ *
+ */
+
 public class Indicator {
+    Image image;
+
     public Indicator(int aInt, Image aImage) {
-        System.out.println("Indicator(IL...Image;) not implemented (" + aInt + ", " + aImage + ")");
+        if (aInt != 0) {
+          System.out.println("Indicator(IL...Image;) unexpected value (" + aInt + ", " + aImage + ")");
+        }
+        setIcon(aImage);
     }
 
-    public void setActive(boolean active) {
-        System.out.println("Indicator.setActive(Z)V not implemented (" + active + ")");
-    }
+    public native void setActive(boolean active);
 
     public void setIcon(Image image) {
-        System.out.println("Indicator.setIcon(IL...Image;)V not implemented.");
+        this.image = image;
     }
 }

java/custom/com/nokia/mid/ui/lcdui/IndicatorManager.java

@@ -1,5 +1,16 @@
 package com.nokia.mid.ui.lcdui;
 
+/*
+ * This class is undocumented.
+ *
+ * We think this class is needed when multiple background MIDlets
+ * need to append an Indicator to the list of the system indicators.
+ * We don't really need to do anything in appendIndicator, since
+ * we're using the Notifications API to implement indicators. When
+ * a notification is created, it is automatically shown to the user.
+ *
+ */
+
 public class IndicatorManager {
     private static IndicatorManager instance = null;
 
@@ -12,7 +23,9 @@ public static IndicatorManager getIndicatorManager() {
     }
 
     public int appendIndicator(Indicator indicator, boolean paramBoolean) {
-        System.out.println("IndicatorManager.appendIndicator(L...Indicator;Z)I not implemented");
+        if (paramBoolean) {
+            System.out.println("IndicatorManager.appendIndicator(L...Indicator;Z)I unexpected value");
+        }
         return 0;
     }
 }

manifest.webapp

@@ -29,6 +29,9 @@
     },
     "video-capture": {
        "description": "Required to take pictures"
+    },
+    "desktop-notification": {
+      "description": "Required to display notifications"
     }
   },
   "type": "privileged"

midp/codec.js

@@ -54,6 +54,13 @@ DataEncoder.prototype.put = function(tag, name, value) {
   });
 }
 
+DataEncoder.prototype.putNoTag = function(name, value) {
+  this.data.push({
+    name: name,
+    value: value,
+  });
+}
+
 DataEncoder.prototype.getData = function() {
   return JSON.stringify(this.data);
 }
@@ -148,6 +155,12 @@ Native.create("com/nokia/mid/s40/codec/DataEncoder.put.(ILjava/lang/String;Z)V",
   this.encoder.put(tag, util.fromJavaString(name), value);
 });
 
+Native.create("com/nokia/mid/s40/codec/DataEncoder.put.(Ljava/lang/String;[BI)V", function(name, data, length) {
+  var array = Array.prototype.slice.call(data.subarray(0, length));
+  array.constructor = Array;
+  this.encoder.putNoTag(util.fromJavaString(name), array);
+});
+
 Native.create("com/nokia/mid/s40/codec/DataEncoder.putEnd.(ILjava/lang/String;)V", function(tag, name) {
   this.encoder.putEnd(tag, util.fromJavaString(name));
 });

midp/localmsg.js

@@ -756,13 +756,145 @@ NokiaImageProcessingLocalMsgConnection.prototype.sendMessageToServer = function(
   }
 };
 
+var NokiaActiveStandbyLocalMsgConnection = function() {
+    LocalMsgConnection.call(this);
+}
+
+NokiaActiveStandbyLocalMsgConnection.indicatorActive = false;
+NokiaActiveStandbyLocalMsgConnection.pipeSender = null;
+
+NokiaActiveStandbyLocalMsgConnection.prototype = Object.create(LocalMsgConnection.prototype);
+
+NokiaActiveStandbyLocalMsgConnection.prototype.recipient = function(message) {
+  switch (message.type) {
+    case "close":
+      DumbPipe.close(NokiaActiveStandbyLocalMsgConnection.pipeSender);
+      NokiaActiveStandbyLocalMsgConnection.pipeSender = null;
+    break;
+  }
+}
+
+NokiaActiveStandbyLocalMsgConnection.prototype.sendMessageToServer = function(message) {
+  var encoder = new DataEncoder();
+
+  var decoder = new DataDecoder(message.data, message.offset, message.length);
+
+  decoder.getStart(DataType.STRUCT);
+  var name = decoder.getValue(DataType.METHOD);
+
+  switch (name) {
+    case "Common":
+      encoder.putStart(DataType.STRUCT, "event");
+      encoder.put(DataType.METHOD, "name", "Common");
+      encoder.putStart(DataType.STRUCT, "message");
+      encoder.put(DataType.METHOD, "name", "ProtocolVersion");
+      encoder.put(DataType.STRING, "version", "1.[0-10]");
+      encoder.putEnd(DataType.STRUCT, "message");
+      encoder.putEnd(DataType.STRUCT, "event");
+
+      var data = new TextEncoder().encode(encoder.getData());
+      this.sendMessageToClient({
+        data: data,
+        length: data.length,
+        offset: 0,
+      });
+    break;
+
+    case "Register":
+      var client_id = decoder.getValue(DataType.STRING);
+      var personalise_view_text = decoder.getValue(DataType.WSTRING);
+      decoder.getValue(DataType.BOOLEAN);
+
+      encoder.putStart(DataType.STRUCT, "event");
+      encoder.put(DataType.METHOD, "name", "Register");
+      encoder.put(DataType.WSTRING, "client_id", client_id);
+      encoder.put(DataType.STRING, "result", "OK"); // Name unknown
+      encoder.putEnd(DataType.STRUCT, "event");
+
+      var data = new TextEncoder().encode(encoder.getData());
+      this.sendMessageToClient({
+        data: data,
+        length: data.length,
+        offset: 0,
+      });
+
+      setZeroTimeout((function() {
+        var encoder = new DataEncoder();
+
+        encoder.putStart(DataType.STRUCT, "event");
+        encoder.put(DataType.METHOD, "name", "Activated");
+        encoder.put(DataType.WSTRING, "client_id", client_id);
+        encoder.putStart(DataType.LIST, "unknown_list");
+        // Unknown DataType.STRING elements
+        encoder.putEnd(DataType.LIST, "unknown_list");
+        encoder.put(DataType.BYTE, "unkown_byte", 1); // Name unknown
+        encoder.put(DataType.SHORT, "unknown_short_1", 0); // Name and value unknown
+        encoder.put(DataType.SHORT, "unknown_short_2", 0); // Name and value unknown
+        encoder.putEnd(DataType.STRUCT, "event");
+
+        var data = new TextEncoder().encode(encoder.getData());
+        this.sendMessageToClient({
+          data: data,
+          length: data.length,
+          offset: 0,
+        });
+      }).bind(this));
+    break;
+
+    case "Update":
+      var client_id = decoder.getValue(DataType.STRING);
+      var personalise_view_text = decoder.getValue(DataType.WSTRING);
+      var activate_scroll_events = decoder.getValue(DataType.BOOLEAN);
+      var content_icon = decoder.getNextValue();
+      var mime_type = decoder.getValue(DataType.STRING);
+      var context_text = decoder.getValue(DataType.WSTRING);
+
+      if (NokiaActiveStandbyLocalMsgConnection.indicatorActive) {
+        NokiaActiveStandbyLocalMsgConnection.pipeSender = DumbPipe.open("notification", {
+          title: personalise_view_text,
+          options: {
+            body: context_text,
+          },
+          icon: content_icon,
+          mime_type: mime_type,
+        }, this.recipient.bind(this));
+      }
+
+      encoder.putStart(DataType.STRUCT, "event");
+      encoder.put(DataType.METHOD, "name", "Update");
+      encoder.put(DataType.WSTRING, "client_id", client_id);
+      encoder.put(DataType.STRING, "result", "OK"); // Name unknown
+      encoder.putEnd(DataType.STRUCT, "event");
+
+      var data = new TextEncoder().encode(encoder.getData());
+      this.sendMessageToClient({
+        data: data,
+        length: data.length,
+        offset: 0,
+      });
+      break;
+
+    default:
+      console.error("(nokia.active-standby) event " + name + " not implemented " +
+                    util.decodeUtf8(new Uint8Array(message.data.buffer, message.offset, message.length)));
+      return;
+  }
+}
+
+Native.create("com/nokia/mid/ui/lcdui/Indicator.setActive.(Z)V", function(active) {
+  NokiaActiveStandbyLocalMsgConnection.indicatorActive = active;
+
+  if (!active && NokiaActiveStandbyLocalMsgConnection.pipeSender) {
+    NokiaActiveStandbyLocalMsgConnection.pipeSender({ type: "close" });
+  }
+});
+
 MIDP.LocalMsgConnections = {};
 
 // Add some fake servers because some MIDlets assume they exist.
 // MIDlets are usually happy even if the servers don't reply, but we should
 // remember to implement them in case they will be needed.
-MIDP.FakeLocalMsgServers = [ "nokia.active-standby", "nokia.profile",
-                             "nokia.connectivity-settings" ];
+MIDP.FakeLocalMsgServers = [ "nokia.profile", "nokia.connectivity-settings" ];
 
 MIDP.FakeLocalMsgServers.forEach(function(server) {
     MIDP.LocalMsgConnections[server] = LocalMsgConnection;
@@ -774,6 +906,7 @@ MIDP.LocalMsgConnections["nokia.phone-status"] = NokiaPhoneStatusLocalMsgConnect
 MIDP.LocalMsgConnections["nokia.file-ui"] = NokiaFileUILocalMsgConnection;
 MIDP.LocalMsgConnections["nokia.image-processing"] = NokiaImageProcessingLocalMsgConnection;
 MIDP.LocalMsgConnections["nokia.sa.service-registry"] = NokiaSASrvRegLocalMsgConnection;
+MIDP.LocalMsgConnections["nokia.active-standby"] = NokiaActiveStandbyLocalMsgConnection;
 
 Native.create("org/mozilla/io/LocalMsgConnection.init.(Ljava/lang/String;)V", function(jName) {
     var name = util.fromJavaString(jName);
@@ -791,7 +924,7 @@ Native.create("org/mozilla/io/LocalMsgConnection.init.(Ljava/lang/String;)V", fu
             // for apps that use the Nokia built-in servers (because we haven't
             // implemented them yet).
             if (!MIDP.LocalMsgConnections[this.protocolName]) {
-                console.warn("localmsg server (" + this.protocolName + ") unimplemented");
+                console.error("localmsg server (" + this.protocolName + ") unimplemented");
                 // Return without resolving the promise, we want the thread that is connecting
                 // to this unimplemented server to stop indefinitely.
                 return;

tests/automation.js

@@ -58,7 +58,7 @@ var gfxTests = [
 ];
 
 var expectedUnitTestResults = [
-  { name: "pass", number: 71197 },
+  { name: "pass", number: 71210 },
   { name: "fail", number: 0 },
   { name: "known fail", number: 180 },
   { name: "unknown pass", number: 0 }