I was looking for a provider to host the HTML5 / node.js Web application that I am blogging about here and there and JSApp.US is the first one that I found.
It is straightforward to use and I have deployed my Web application on it. You can try it by yourself on your iPhone or iPad by going to http://board.jsapp.us/.
At first, it complained that __dirname was not defined when server.js is trying to read files based on the URL path. I modified server.js to remove the leading / from the path and it works fine:
// won't work on JSApp.us
fs.readFile(__dirname + path, function(err, data) {
...
}
// but this works
fs.readFile(path.substring(1, path.length), function(err, data) {
...
}
The offline support does not work: somehow this provider does not return the Content-Type HTTP header set by server.js. Since the cache manifest is not served with the expected text/cache-manifest, I suppose that Safari does not take it into account and bypass the offline configuration.
update: I was wrong the cache.manifest file is returned with the correct Content-Type:
I don't know why offline support is not working... The rest of the application seems to work fine though.
It will make the next version of the application more interesting. I want to add Web Sockets support to display the pieces of the other users on the Web application (in addition to its own piece). With this hosting provider, I'll be able to release a version that everyone will be able to try.
As an aside, it uses SkyWriter (né Bespin) to edit the code and the integration is pretty slick.
Let's continue working on the HTML5 Web Application for the iPhone with node.js
Last time, I created the first version of the Web application to move a piece when the user moves the iPhone and coded a simple Web server on top of node.js.
The Web application works fine but it is not pretty and there are a few things we can improve. Before looking at Web Sockets and other fancy code, let's make the Web application prettier.
iPhone Standalone Web Application
The major annoyance is that Safari chrome takes a lot of space and hides the bottom of the board:
The viewport meta ensures that the Web page will be sized to the device width and prevents the user to change the page scale (by pinching it).
The apple-mobile-web-app-capable will launch the Web application in full-screen mode (without Safari chrome) to look like a native application. The Web application must be added to the iPhone home screen and start from there to appear in full-screen mode.
This cache manifest tells the Web browsers to call all these files to run the Web application offline.
This cache manifest must be declared in the entry point of the Web application (index.html in this case) with the manifest attribute of the html element:
Finally, we need to update server.js to send the cache.manifest file with the correct HTTP Content-Type. Only the getContentType()function needs to be modified:
function contentType(path) {
if (path.match('.js$')) {
return "text/javascript";
} else if (path.match('.css$')) {
return "text/css";
} else if (path.match('.manifest$')) {
return "text/cache-manifest";
} else {
return "text/html";
}
}
With this modification, cache.manifest will be sent to the Web browser with the correct text/cache-manifest Content-Type.
We must restart the server to take into account the server.js modification:
$ node.js server.js
HTTP server running at htpp://0.0.0.0:8080
I can then reload the Web application and add it to the iPhone home screen. With offline support, I will be able to use the Web application even if the server is not running or unreachable.
Here is a small video of the result with the updated Web application:
Note the black status bar and the full screen mode after I started the Web application from the iPhone home screen. It is indistinguishable from a native application but runs on the Web (it's not obvious from the video but the camera was recording from above: the iPhone was held horizontally).
Source Code
I have pushed the application on Github. You can clone it with Git:
git clone git://github.com/jmesnil/board-node.git
Conclusion
By adding a few meta information to the Web application, it is possible to make it look better integrated to the iPhone. Offline support is trickier than this simple example make it look like but it gives the right idea to start dealing with it.
Next step is to add Web Sockets support to the node.js to display the moving pieces of other users on the Web application.
Update:I have written another post about adding offline support to the Web application and making it look like a native iPhone application.
On the server, I want to learn more about node.js which is an interesting way to develop server-side applications. On the client-side, I also wanted to check what can be done with HTML5 on iPhone and iPad with the release of iOS 4.2.1.
I will write a simple web application to do both at the same time. The idea is simple enough but will allow me to dive into node.js and HTML5 quite extensively.
The idea is to write a web application that display a piece moving on a board when the user moves its device. Later on, I will expand it so that the user will also see the pieces of all others users connected to the server.
But the first iteration will be enough to familiarize with:
I will use node.js as my Web server (I installed it from Git by following the build instructions on its web site).
The first version of the server needs to serve static files with the correct HTTP Content-Type. At first, it will serve only HTML pages, CSS stylesheets and JavaScript files.
The whole server.js code is:
var http = require('http');
var url = require('url');
var fs = require('fs');
var sys = require('sys');
// the HTTP server
var server;
// the HTTP port
var port = 8080;
server = http.createServer(function(req, res){
var path = url.parse(req.url).pathname;
if (path == '/') {
path = '/index.html'
}
console.log("serving " + path);
fs.readFile(__dirname + path, function(err, data){
if (err) {
res.writeHead(404);
res.end();
} else {
res.writeHead(200, {'Content-Type': contentType(path)});
res.write(data, 'utf8');
res.end();
}
});
});
function contentType(path) {
if (path.match('.js$')) {
return "text/javascript";
} else if (path.match('.css$')) {
return "text/css";
} else {
return "text/html";
}
}
server.listen(port);
console.log("HTTP server running at htpp://0.0.0.0:" + port );
The code is straightforward: when a request is handled by the server, it looks in the current directory (where server.js is) for a file with the given path and writes its content in the HTTP response body. The contentType(path) function checks the file suffix to use the correct HTTP Content-Type for the response.
It will serve files from http://0.0.0.0:8080/. For the rest of the example, I will use the name of my machine, blackbook.local: to access the Web application from my iPhone, I am using http://blackbook.local:8080.
In future iterations, I will add more interesting code to node.js (to use WebSockets for example) but for the moment this simple server is enough.
Web Application
Let's now focus on the client-side part of the Web application.
index.html
The Web application is loaded from a single HTML5 page, index.html:
The piece has a center position with its coordinates (initially at the center of the board) and its acceleration on the x and y axes, and its color is black.
I use jQuery to bootstrap the application when the document is ready:
$(document).ready(function() {
var board = document.getElementById("board");
var context = board.getContext("2d");
window.addEventListener("devicemotion", function(event) {
var accel = event.accelerationIncludingGravity;
piece.center = computeCenter(piece.center, accel);
drawGrid(context);
drawPiece(context, piece);
}, true);
});
First we keep a reference on the board canvas that was declared in the HTML page and its associated 2D context. The context will be used to draw the piece and the board on the canvas.
We use the DeviceOrientation API (supported by the iPhone and the iPad since iOS 4.2.1) to detect the acceleration of the device. Periodically, the browser will call the handler associated to the devicemotion event. When that happens, the handler retrieves the accelerationIncludingGravity property, compute the new center position of the piece and draw the board and the piece on the canvas.
The method to draw the board is using the 2D context (the board is displayed as a grid):
function drawBoard(context) {
context.clearRect(0, 0, kBoardWidth, kBoardHeight);
for (var x = 0.5; x < kBoardWidth; x += 10) {
context.moveTo(x, 0);
context.lineTo(x, kBoardHeight);
}
for (var y = 0.5; y < kBoardHeight; y += 10) {
context.moveTo(0, y);
context.lineTo(kBoardWidth, y);
}
context.strokeStyle = "#eee";
context.stroke();
}
The code to draw the piece is also using the 2D context to draw a circle from the piece's center and its color:
Finally, we need to compute the updated position of the piece's center based on its current position and the acceleration information from the browser:
function computeCenter (oldCenter, acceleration) {
newCenter = {};
newCenter.xShift = oldCenter.xShift * 0.8 + acceleration.x * 2.0;
newCenter.yShift = oldCenter.yShift * 0.8 + acceleration.y * 2.0;
newCenter.x = oldCenter.x + oldCenter.xShift;
// use *minus* to compute the center's new y
newCenter.y = oldCenter.y - oldCenter.yShift;
// do not go outside the boundaries of the canvas
if (newCenter.x < kCircleRadius) {
newCenter.x = kCircleRadius;
}
if (newCenter.x > kBoardWidth - kCircleRadius) {
newCenter.x = kBoardWidth - kCircleRadius;
}
if (newCenter.y < kCircleRadius) {
newCenter.y = kCircleRadius;
}
if (newCenter.y > kBoardHeight - kCircleRadius) {
newCenter.y = kBoardHeight - kCircleRadius;
}
return newCenter;
}
To smooth the movement and increase the acceleration when the mobile is moved, I applied a low-pass filter:
The rest of the method ensures that the piece will remain in the boundaries of the board.
screen.css
Last thing is to make sure that the canvas fills the whole Web page by removing the margin and padding on the body element. This is done through CSS in the screen.css file:
body {
margin: 0px;
padding: 0px;
}
All these files are located in the same directory than server.js.
Run the example
Let's start the node.js server:
$ node server.js
HTTP server running at htpp://0.0.0.0:8080
Now, from my iPhone, I go to the Web page on http://blackbook.local:8080 (if you go on the Web application from your machine, nothing will happen since the devicemotion event is not available on desktop browsers).
As I have not found a way to prevent the iPhone to change the screen orientation when it is moved, I have locked the iPhone in portrait mode before running the Web application.
Here is a small video of the result:
It's not obvious from the video but the camera was recording from above: the iPhone was held horizontally.
Source Code
I have pushed the application on Github. You can clone it with Git:
git clone git://github.com/jmesnil/board-node.git
The code is slightly different as I have already started the next iteration but the main idea remains the same.
Conclusion
With a few lines of JavaScript on both the client and server sides, it is possible to:
use node.js to write a Web server returning files
use the Canvas API to draw things on a Web page
use the DeviceOrientation Event API orientation to have interaction between the device and the Web page
Next steps will be to improve the user experience:
make the application appear as a standalone application on the iPhone home screen and remove Safari chrome
support offline mode to use the Web application even when the server is not running
jmx4r 0.1.3 has just been released (jmx4r is a JRuby library which makes it super easy to write simple Ruby scripts to manage Java & JRuby applications using JMX).
There is a single new feature on this release:
JMX CompositeData attributes can now be accessed as Ruby attributes.
Before, to access the committed attribute of the heap_memory composite data, you needed to write:
memory.heap_memory_usage.get("committed")
# or
memory.heap_memory_usage["committed"]
while now, you can simply do:
memory.heap_memory_usage.committed
You write the attribute like a normal snake_cased attribute and jmx4r will automatically retrieve the corresponding CamelCased attribute from the composite data.
When I pushed the new gem on RubyGems.org, I also noticed that the RDoc is automatically published to rubydoc.info and looks much better that the old version that I was pushing to Rubyforge.
As usual, to get this new release, just update the rubygem:
The previous book, "The Hunter", was the best comic I read in 2009 right after David Mazzucchelli's Asterios Polyp. I expect "The Outfit" to be just as riveting or even better.
Oracle and Apple today announced the OpenJDK project for Mac OS X. Apple will contribute most of the key components, tools and technology required for a Java SE 7 implementation on Mac OS X, including a 32-bit and 64-bit HotSpot-based Java virtual machine, class libraries, a networking stack and the foundation for a new graphical client. OpenJDK will make Apple's Java technology available to open source developers so they can access and contribute to the effort.
That's the right move from Apple: they focus on their platforms (iOS, Mac OS X) and the Web (with WebKit) and let the OpenJDK community handles the Java platform.
