Tag Archives: JavaScript

Matters relating to the JavaScript programming language

Merry Christmas 2015

As another year draws to a close at Cranfield University, sure enough we have another Christmas map for you. As with previous years, we’ve collected a sample of tweets from Twitter that match a number of Christmas related keywords and mapped them using the same process we outlined last year.

The colour range from green to red indicates the density of Christmas related tweets from low to high in that county, relative to the normal density of twitter activity in that area (taken from a random sample of all tweets in the UK).

We’ll let you draw your own conclusions from the map. This time we thought we’d use the opportunity to focus on some of the web mapping technologies we’ve started using this year in other projects and hope to develop our use of heading into 2016. The biggest difference between the map you see above and some of the other maps we’ve published in the past is that this one doesn’t makes use of any GIS server or map hosting platform. Traditionally we’ve used either Geoserver or ArcGIS Server to publish our map tiles and other geospatial data for consumption with JavaScript web mapping APIs. Alternatively, web map hosting services can be used if one doesn’t have access to their own GIS Server, these include ArcGIS Online, Mapbox, CartoDB and others. The example here doesn’t use any of these services, but instead is running from a set of map tiles hosted on this very webserver. Interactivity (roll your mouse over the map to view the county names) is provided via a set of UTF-Grid tiles, also hosted on this webserver.

UTFGrid tiles use a combination of JSON encoding and ASCII grid files that sit alongside the map’s image tiles. For each PNG image tile there is a corresponding ASCII tile with a one pixel to one ASCII character mapping. An accompanying JSON lookup table provides the full set of attributes so that you can go beyond a simple raster map and offer full identify style interactivity.

UTFGrid functionality is available in many of the popular JavaScript web mapping APIs, either out of the box or as easily downloadable plugins. This particular map makes use of the Mapbox JS API, an extension of the Leaflet API.

The tiles used by this map are generated using the TileMill software and stored as a .mbtiles file (which is actually an SQLite database). A small PHP file, acting as a tile server, exposes this SQLite/MBTiles database to web mapping APIs as a large nested folder of image and UTFGrid files in the usual {z}/{x}/{y}.png or {z}/{x}/{y}.json fashion.

We like this approach to web mapping as it is reasonably lightweight and portable. The whole application, including web pages, JavaScript, map tiles and PHP tile server can be picked up and dropped onto any web server that supports PHP and is ready to go. It might not provide some of the advanced features you get with more heavyweight solutions, but a simple interactive map with query-able attributes is often all that’s needed for many web mapping applications. It’s also extremely fast and can be built using entirely open source software and tools.

More information on some of the packages and technologies used can be found here:

Merry Christmas and a happy New Year from all at Geothread!

Building a mobile mapping application

Leaflet mobile mapping application

Leaflet mobile mapping application

Our earlier articles on mobile application development demonstrated the process of getting an app up and running on an Android phone using Adobe PhoneGap and GitHub. For the purposes of this article we’re going to assume that you are now comfortable with that process and will demonstrate how easy it is begin building mobile mapping applications. This is something we are developing a lot of interest in here at Cranfield University.

As with previous examples, the app is going to be based on a package of HTML, CSS and JavaScript code and will therefore use one of the many JavaScript web mapping APIs available. Any of the following APIs would work well:

  • Google Maps API
  • ArcGIS API for Javascript
  • Leaflet
  • OpenLayers
  • OS OpenSpace API

The decision on which one to use will depend on what the functional requirements of your app are, how familiar you are with a particular API and a number of other factors. For this example we are going to build a simple mobile web map using the Leaflet mapping API. Leaflet is an extremely lightweight JavaScript library which makes it ideal for bundling with a mobile app, as we shall see shortly. It is also relatively simple to use and has great flexibility for puling in geospatial resources from a number of different sources, in a variety of formats.

The Leaflet website provides a page of useful examples to get you started with creating basic web maps. Below is a typical web page that would display a basic web map using Leaflet. You can save this code to a HTML file and view it in a browser to test it out for yourself.

<!DOCTYPE html>
<html>
<head>
<title>Basic Leaflet Map</title>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.css" />

<style type="text/css">
body {
	padding: 0;
	margin: 0;
}
html, body, #map {
	height: 100%;
}
</style>
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
</head>
<body>
<div id="map"></div>
<script src="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.js"></script> 
<script>
	var map = L.map('map').setView([52.04, -0.73], 12);
        L.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
		maxZoom: 18			
	}).addTo(map);
</script>
</body>
</html>

The process of turning this into a mobile app is very straightforward, assuming you’ve already got your PhoneGap/Cordova framework in place. Rather than build a new index.htm for our project, we’ll take the default index.htm that has been created for us and drop in the relevant sections of the Leaflet map example above into the correct places. The index.htm file that sits within the www folder of you mobile app framework (taken from the default PhoneGap example on GitHub) should look something like this:

<html>
    <head>
        <meta charset="utf-8" />
        <meta name="format-detection" content="telephone=no" />
        <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi" />
        <link rel="stylesheet" type="text/css" href="css/index.css" />
        <title>Hello World</title>
    </head>
    <body>
        <div class="app">
            <h1>PhoneGap</h1>
            <div id="deviceready" class="blink">
                <p class="event listening">Connecting to Device</p>
                <p class="event received">Device is Ready</p>
            </div>
        </div>
        <script type="text/javascript" src="phonegap.js"></script>
        <script type="text/javascript" src="js/index.js"></script>
        <script type="text/javascript">
            app.initialize();
        </script>
    </body>
</html>

The key parts of the Leaflet map example are as follows:

<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.css" />

This ensures the appropriate CSS files are loaded so that the map is is styled correctly.

body {
	padding: 0;
	margin: 0;
}
html, body, #map {
	height: 100%;
}

Here we are defining some layout parameters, including how much space the #map element of the page should use

<div id=”map”></div>

This is the container in the body of the page that will house our map

<script src="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.js"></script> 

Load in the Leaflet API

<script>
	var map = L.map('map').setView([52.04, -0.73], 12);
	L.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
		maxZoom: 18			
	}).addTo(map);
</script>

This is the code that generates and renders the map on the page.

Dropping these elements into our existing index.htm whilst retaining the important components (such as app.initialise(); and the calls to phonegap.js and js/index.js) that are already there, gives a page that looks as follows:

<html>
    <head>
        <meta charset="utf-8" />
        <meta name="format-detection" content="telephone=no" />
        <meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi" />
        <link rel="stylesheet" type="text/css" href="css/index.css" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0">
		<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.css" />
        <title>Basic Leaflet Mobile Map</title>
    </head>
    <body>
        <div class="app">
            <div id="map"></div>

        </div>
	<script src="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.js"></script> 
	<script>
		var map = L.map('map').setView([52.04, -0.73], 12);		
	        L.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
			maxZoom: 18					
		}).addTo(map);
	</script>
        <script type="text/javascript" src="phonegap.js"></script>
        <script type="text/javascript" src="js/index.js"></script>
        <script type="text/javascript">
            app.initialize();
        </script>
    </body>
</html>

This can now be compiled and deployed to your device using the process detailed earlier to give you a simple mobile mapping application.

Hosting libraries and APIs locally

Before we finish, we shall make one more minor alteration to our app to improve efficiency and performance. Currently the app loads up the Leaflet API from http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.js. We are going to take a copy of the full API, copy it to our app’s folder tree and deploy it to the phone so that our app can reference it locally rather than having to load it over web each time the app is launched. This will reduce the reliance on network connectivity and speed up application launch times as well as eliminate any reliance on the Leaflet website; we want our app to continue to work regardless of whether any remote websites may be experiencing problems of their own.

The full leaflet API can be downloaded here:
http://leafletjs.com/download.html
Unpack the zipfile and place the contents into a subfolder of your www folder named leaflet within your mobile app framework. All that needs to be done now is to modify the calls in your code that load the Leaflet API and CSS so that they reference your local copies. They should be changed from

<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.css" />
<script src="http://cdn.leafletjs.com/leaflet-0.7.1/leaflet.js?2"></script>

to

<link rel="stylesheet" href="leaflet/leaflet.css" />
<script src="leaflet/leaflet.js"></script>

This change will make your app almost fully self sufficient, without any reliance on loading libraries from external websites. Note that the map tiles that make up your map are still being loaded from the following location:
http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png
Your app will therefore still require a working internet connection in order to function correctly. In our next post we’ll discuss bundling a selection of map tiles with your application so it can be used completely offline with no internet connection

Leaflet mobile mapping application

Leaflet mobile mapping application

Mobile App Development with Dojo

Our earlier blog article about Mobile App Development With PhoneGap showed how easy it is to develop a basic mobile app using the Apache Cordova / Adobe PhoneGap framework, compiled with Adobe PhoneGap Build. However, the resultant app is not styled in a way that resembles a ‘native app’.
RockPaperScissors_Game
In developing apps here at Cranfield University we are increasingly adopting the ‘Dojo’ JavaScript API (http://dojotoolkit.org/).
Dojo
Dojo allows a powerful open source API framework for developing industry-strength web applications, and includes a powerful suite of tools for developing mobile apps. To give an example of this in action, following the previous ‘Rock, Paper, Scissors’ app article, the following code can be substituted for the file ‘index.htm’.

<!DOCTYPE html>
<html>
	<head>
		<meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi" />
		<meta name="apple-mobile-web-app-capable" content="yes"/>
		<meta names="apple-mobile-web-app-status-bar-style" content="black-translucent" />
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<!--<link rel="stylesheet" type="text/css" href="css/index.css" />-->
		<title>Rock Paper Scissors Game</title>
		<!-- set Dojo configuration, load Dojo -->
		<script>
			dojoConfig= {
				async: true,
				mblAlwaysHideAddressBar:true
			};
		</script>
		<script src="dojox/mobile/deviceTheme.js"></script>
		<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/dojo/1.9.2/dojo/dojo.js"></script> 
		<script>
			require(["dojox/mobile",
			         "dojox/mobile/parser",
			         "dojox/mobile/compat",
			         "dojox/mobile/deviceTheme",
				 "dojox/mobile/Heading",
			         "dojox/mobile/ScrollableView",
			         "dojox/mobile/Button",
			         "dojo/dom-attr",
			         "dojo/_base/array",
			         "dojox/mobile/compat",
			         "dojo/domReady!"],
					function(dm, parser, compat, deviceTheme, heading, scrollableView,
					         button, domAttr, baseArray, compat) {
					parser.parse();
			});
		</script>
	<script type="text/javascript">
		var CHOICE = { // set up enumerations
			ROCK     : {value: 1, name: "Rock", code: "R"}, 
			PAPER    : {value: 2, name: "Paper", code: "P"}, 
			SCISSORS : {value: 3, name: "Scissors", code: "S"}
		};
		var plays = 0;
		var humanWins = 0;
		var compWins  = 0;

		function playGame(play) {
			if(typeof play === 'undefined'){return;}
			var humanChoice = null;
			var compChoice  = null;
			plays++;
			
			if (play==='R') {
				humanChoice = CHOICE.ROCK;
			} else if (play==='P') {
				humanChoice = CHOICE.PAPER;
			} else if (play==='S') {
				humanChoice = CHOICE.SCISSORS;
			}
	
			var computer = (Math.floor( Math.random() * 3 + 0.5 ));
				if ( computer === 1 ) {
					compChoice = CHOICE.ROCK }
				else { if ( computer === 2 ) {
					compChoice = CHOICE.PAPER }
				else { 
					compChoice = CHOICE.SCISSORS }
				}
			document.getElementById('result').innerHTML="<p>You chose '" + humanChoice.name + "' and I chose '" + compChoice.name + "'</p>";
			<!--document.getElementById('log').innerHTML+="H:" + humanChoice.code + " C:" + compChoice.code + "|";-->
	
			var win = humanChoice.value - compChoice.value;
			if ( win === 0 ) { 
				document.getElementById('result').innerHTML += "<p><b>So we've drawn</b></p>" } 
			else {
				if ( win === -2 || win === 1 ) { 
					document.getElementById('result').innerHTML += "<p><b>So you win</b></p>"; humanWins++; }
				else {
					if ( win === -1 || win === 2 ) { 
						document.getElementById('result').innerHTML += "<p><b>So I win</b></p>"; compWins++; }
					else {}
				}
			}
			document.getElementById('tally').innerHTML = "<p><i>Leaderboard</i>&nbsp;&nbsp;Plays:&nbsp;" + plays + "<br />Your wins:&nbsp;" + humanWins + "&nbsp;&nbsp;&nbsp;My wins:&nbsp;" + compWins + "&nbsp;&nbsp;&nbsp;Draws:&nbsp;" + (plays - (humanWins + compWins)) + "</p>";
			if ( compWins < humanWins ) { 
				document.getElementById('tally').innerHTML += "<p>You're in the lead</p>"; } 
			else if ( compWins > humanWins ) {
				document.getElementById('tally').innerHTML += "<p>I'm in the lead</p>"; } 
			else if ( compWins == humanWins ) {
				document.getElementById('tally').innerHTML += "<p>We're running head to head</p>"; }
		}
		
		function restart() {
			plays = 0;
			humanWins = 0;
			compWins  = 0;
			document.getElementById('result').innerHTML = "&nbsp;";
			document.getElementById('tally').innerHTML = "&nbsp;";
			document.getElementById('log').innerHTML = "&nbsp;";
		}
		</script>
		<style type="text/css">
			html, body{
				height: 100%;
				overflow: hidden;}
			p {font-size:25px;}
			button {font-size:45px; width:250px; margin:20px 50px;}
			.mblBlueButton {
				background-image: -webkit-gradient(linear, left top, left bottom, from(#7a9de9), to(#2362dd), color-stop(0.5, #366edf), color-stop(0.5, #215fdc));
				background-image: linear-gradient(to bottom, #7a9de9 0%, #366edf 50%, #215fdc 50%, #2362dd 100%);
				color: white;
			}
			.mblBlueButtonSelected {
				background-image: -webkit-gradient(linear, left top, left bottom, from(#8ea4c1), to(#4a6c9b), color-stop(0.5, #5877a2), color-stop(0.5, #476999));
				background-image: linear-gradient(to bottom, #8ea4c1 0%, #5877a2 50%, #476999 50%, #4a6c9b 100%);
			}
		</style>
	</head>
	<body style="visibility:hidden;">
	<div id="settings" dojoType="dojox/mobile/View">
		<div dojoType="dojox/mobile/Heading" data-dojo-props="fixed: 'top'">
			Rock Paper Scissors Game
		</div>
		<div data-dojo-type="dojox.mobile.RoundRect">
			<h2 dojoType="dojox.mobile.RoundRectCategory">Choose ...</h2>
			<button dojoType="dojox.mobile.Button" class="mblBlueButton" label="Rock" onClick="playGame('R')"></button>
			<button dojoType="dojox.mobile.Button" class="mblBlueButton" label="Paper" onClick="playGame('P')"></button>
			<button dojoType="dojox.mobile.Button" class="mblBlueButton" label="Scissors" onClick="playGame('S')"></button>
			<button dojoType="dojox.mobile.Button" class="mblButton" label="Restart" onClick="restart()"></button>
			<span id="result">&nbsp;</span><br />
			<span id="tally">&nbsp;</span><br />
			<span id="log">&nbsp;</span><br />
		</div>
	</div>
	</body>
</html>

The result of this is a styled app taking on the visual characteristics of a native Android app. Note the use of the Dojo ‘dojox/mobile/deviceTheme’ require. This permits automatic styling for all the different mobile platforms. For more information, see the excellent mobile tutorials on the Dojo website, as well as the mobile showcase. Note also that this code includes a live online call to load the Dojo API. Clearly this will not work if your device is offline. To resolve this, a further refinement would be to create a custom API library build stored locally containing the Dojo code needed.
RockPaperScissors_Game_Dojo

Mobile App Development With PhoneGap

Introduction – Building mobile apps
One area of computing we are developing a keen interest in here at Cranfield University is the development of mobile apps. The future is firmly mobile and meeting the explosive growth in mobile phone and tablet computing throws traditional software development approaches in the air. New approaches are needed to develop app tools for location-based mapping and GIS. With much to learn to achieve this, this article outlines some of the basic steps needed to develop apps for a mobile device. The app developed here will be a simple ‘RockPaperScissors’ game, ported to an Android phone, and using the PhoneGap development platform. You will need an Android device.

Cross-platform development
The first issue to recognise is the sheer diversity of mobile devices and operating systems available – with Apple IOS, Google Android, Windows Phone and Blackberry to choose from by example. Each platform has its own preferred development tools and deployment approaches. Developing the personal skills to develop native code apps for each of these platforms would be a huge task. So ideally a means is needed to allow the development of one set of code that can then be ported across these platforms. A number of tools exist that achieve this, but one that stands out for us is the combined offering of Apache Cordova (http://cordova.apache.org/) and Adobe PhoneGap (https://build.phonegap.com/).

PhoneGap and Cordova
Apache Cordova is a platform for building native mobile applications using HTML, CSS and JavaScript. If you can develop a webpage, you should be able to build a Cordova app. Apache note that “Cordova graduated in October 2012 as a top level project within the Apache Software Foundation (ASF)” and that “it will always remain free and open source”. The software company Adobe have then picked up Cordova and used it to produce their own SDK ‘PhoneGap’. Like Cordova, PhoneGap allows native mobile app development using only HTML, CSS and JavaScript. In addition to PhoneGap itself, Adobe also provide a cloud-based mobile app compiler for PhoneGap apps, capable of producing compiled code for each of the major mobile architectures, PhoneGap Build (https://build.phonegap.com/): this is used in developing the app here.

PhoneGapBuild

Setup – preparing to build a mobile app
PhoneGap Build accepts a package of the HTML, CSS and JavaScript code. PhoneGap Build is designed to retrieve code held in the GitHub repository (https://github.com/). Therefore, if you don’t already have accounts, for this exercise you will need to create personal accounts in both PhoneGap Build, and in GitHub. You must also install and configure a copy of Git on your local development computer. For Windows PCs, the best option is ‘GitHub for Windows’ (http://windows.github.com/).
GitForWindows
Once installed, Git can be linked by association with your github.com account. The local Git acts to hold a set of files linked to a software project (a ‘repository’), these can then be uploaded to the GitHub website (automatically), and from there, loaded straight into the PhoneGap Build tool. Local project files (HTML, CSS and JavaScript code) can be edited by any generic text editor, for example NotePad++ (http://notepad-plus-plus.org/).

GitHub

Summary of setup tasks:
1. Create account at GitHub (https://github.com/).
2. Create account at PhoneGap Build Build (https://build.phonegap.com/).
3. Install a local copy of ‘GitHub for Windows’ (http://windows.github.com/) – link to GitHub.
4. If needed, install a good text editor such as NotePad++ (http://notepad-plus-plus.org/).

Assembling the source code
GitHub already contains a basic PhoneGap example app to get you going. This ‘repo’ (repository) can be copied and then adapted to create your own custom project. To achieve this, first search for, then download as a ‘zip’ file the existing ‘phonegap / phonegap-start’ repo from the GitHub website. After creating a new local Git repo, the ‘www’ folder from the ‘phonegap-start’ app can be copied to the new repo folder, and then adapted by editing.

The basic workflow for developing a basic mobile app is as follows:
1. Log in to GitHub and locate the existing code ‘phonegap / phonegap-start’ (https://github.com/phonegap/phonegap-start).
2. Download this example repo as a zip file to a local file – all required source code is included.
3. Use ‘GitHub for Windows’ to create your own repo, called ‘RockPaperScissors’.
4. Now extract the ‘www’ folder from the downloaded zip file and copy to the new repo folder.
5. Next, you can edit and adapt the code. For this rock paper scissors game tutorial, replace the contents of the file ‘index.htm’ with the following code:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8" />
		<meta name="format-detection" content="telephone=no" />
		<meta name="viewport" content="user-scalable=no, initial-scale=1, maximum-scale=1, minimum-scale=1, width=device-width, height=device-height, target-densitydpi=device-dpi" />
		<link rel="stylesheet" type="text/css" href="css/index.css" />
		<title>Rock Paper Scissors Game</title>
		<style type="text/css">
			p, form {font-size:25px;}
			button  {font-size:45px; width:200px; margin:25px 50px;}
		</style>
	</head>
	<body>
	<h1>Rock Paper Scissors Game</h1>
	<br />
	<p><i>What do you choose?</i></p>
	<button type="button" onclick="PlayGame('R')">Rock</button></br>
	<button type="button" onclick="PlayGame('P')">Paper</button></br>
	<button type="button" onclick="PlayGame('S')">Scissors</button></br>
	<span id="result">&nbsp;</span><br />
	<span id="tally">&nbsp;</span><br />
	<span id="log">&nbsp;</span><br />
				
	<script type="text/javascript">
		var CHOICE = { // set up enumerations
			ROCK     : {value: 1, name: "Rock", code: "R"}, 
			PAPER    : {value: 2, name: "Paper", code: "P"}, 
			SCISSORS : {value: 3, name: "Scissors", code: "S"}
		};
		var humanWins = 0;
		var compWins = 0;

		function PlayGame(play) {
			var humanChoice;
			var compChoice;
	
			if (play==='R') {
				humanChoice = CHOICE.ROCK;
			} else if (play==='P') {
				humanChoice = CHOICE.PAPER;
			} else if (play==='S') {
				humanChoice = CHOICE.SCISSORS;
			}
	
			var computer = (Math.floor( Math.random() * 3 + 0.5 ));
				if ( computer === 1 ) {
					compChoice = CHOICE.ROCK }
				else { if ( computer === 2 ) {
					compChoice = CHOICE.PAPER }
				else { 
					compChoice = CHOICE.SCISSORS }
				}
			document.getElementById('result').innerHTML="<p>You chose '" + humanChoice.name + "' and I chose '" + compChoice.name + "'</p>";
			//document.getElementById('log').innerHTML+="H:" + humanChoice.code + " C:" + compChoice.code + "-";
	
			var win = humanChoice.value - compChoice.value;
			if ( win === 0 ) { 
				document.getElementById('result').innerHTML += "<p><b>So we draw</b></p>" } 
			else {
				if ( win === -2 || win === 1 ) { 
					document.getElementById('result').innerHTML += "<p><b>So you win</b></p>"; humanWins++; }
				else {
					if ( win === -1 || win === 2 ) { 
						document.getElementById('result').innerHTML += "<p><b>So I win</b></p>"; compWins++; }
					else {}
				}
			}
			document.getElementById('tally').innerHTML = "<p><i>Leaderboard:</i><br />Your wins: " + humanWins + "&nbsp;&nbsp;&nbsp;My wins: " + compWins + "</p>";
			if ( compWins < humanWins ) { 
				document.getElementById('tally').innerHTML += "<p>You're in the lead</p>"; } 
			else if ( compWins > humanWins ) {
				document.getElementById('tally').innerHTML += "<p>I'm in the lead</p>"; } 
			else if ( compWins == humanWins ) {
				document.getElementById('tally').innerHTML += "<p>We're running head to head</p>"; } 		
		}
		</script>
		<script type="text/javascript" src="js/index.js"></script>
		<script type="text/javascript">
			app.initialize();
		</script>
	</body>
</html>

Maths credit: Liam

6. Once the file is saved, be sure the local Git recognises these files as having been added to the local repo, then commit the new repo up to the GitHub website. If further edits are made to the code, be sure to ‘sync’ the fileset in the local Git with the GitHub, thus ensuring the latest files are copied across.

Note, a quicker alternative to these steps just to get you going, is just to create a new ‘fork’ (copy) of our working app – search for the public repo ‘rendzina / RockPaperScissors’ (https://github.com/rendzina/RockPaperScissors).

Compiling and installing the app
Once the app is completed to your satisfaction in the local repo, and then committed and uploaded to the GitHub, it can be accessed by PhoneGap build. Once the final version of the app is ready in GitHub, open PhoneGap Build in a browser. At this point also, you can connect the Android device physically to the local computer via a USB cable. The default USB connection will allow you to upload the compiled Android Package (apk) file to the device’s ‘downloads’ folder, from where it can be installed.
Installed_app

The basic workflow for compiling and installing the app is as follows:
1. Log in to PhoneGap Build and select ‘new app’.
2. You can now either upload a zipfile of the local app fileset, or direct PhoneGap Build to the Github repo by URL (e.g. https://github.com/<yourusername>/RockPaperScissors).
3. Once loaded, select ‘Ready to build’ to compile the app. Note that if the code was sourced from GitHub, the ‘Hydration’ option can usefully be selected for managing updates once it is installed on a device.
4. Once the app is compiled, select the Android icon to save the compiled ‘apk’ file off locally.
5. Once saved, the ‘apk’ file can be uploaded to the device’s ‘download’ folder. Once uploaded, the file can then be installed directly from file on the device. Note that to do this you may need to set an option allowing apk files uploaded in this manner to be installed.

Hopefully, you can now run your app on the device!
RockPaperScissors_Game
Making further edits to your code
Making further edits to the code involves simply re-editing source code files, uploading it and then recompiling the app. If GitHub was used, then making any further committed edits to the web GitHub code fileset, compiled in PhoneGap Build, will result in your being given an option to update the app directly on the device.

The basic workflow for implementing further code edits is as follows:
1. Make required code changes to the local app code fileset (HTML, CSS and JavaScript files).
2. In the local Git, make a new Commit for these edits, then ensure the newly committed fileset is synchronised with the web GitHub repo.
3. Once that is done, Select ‘Update code’ in PhoneGap Build (assuming the app source was GitHub) – the latest fileset is pulled over from GitHub and a new compile job queued.
4. If ‘Hydration’ was enabled, you can try running the app again and it should reload the updated app (by a wireless connection if available – you don’t need to have a USB cable). If you didn’t use Hydration, you will need to uninstall the app, copy over the latest apk file and reinstall before running.
Hydration
Next steps
Hopefully by the end of this you will have a working mobile app using PhoneGap. However, this is just the start of mobile app development. Firstly note the user interface does not currently look like a native mobile app. This can be solved by developing the software using a further third party JavaScript library, such as Dojo (http://dojotoolkit.org/) or JQuery (http://jquery.com/), both of which have powerful mobile development options. We prefer the Dojo framework and a further blog article shows how to adapt the game here for Dojo. Developing in JavaScript also has advantages in that third party mapping and GIS APIs are also available for use, such as Leaflet (http://leafletjs.com/).

The development environment used can also be enhanced. The example above just uses a good text editor to edit the HTML, CSS and JavaScript code. A better approach is to use an Integrated Development Environment (IDE) such as Eclipse (http://www.eclipse.org/) or NetBeans (https://netbeans.org/). These are generic cross-platform tools. However, it is also perfectly possible to use the native platform-specific development tools to develop apps. For example, for Android this is the Google Android Developer Tools plugin (ADT) for Eclipse, or the new Android Studio (http://developer.android.com/tools/). These latter tools also usefully include device emulators to try out your app on before deployment. Establishing the ‘software stack’ required for this type of development with PhoneGap becomes more complex, as a number of dependent software tools need to be installed – this will form the basis for a later article here on GeoThread.
PhoneGap_Logo

Extracting legend RGB values from ArcGIS Server using JavaScript

Most technical issues that developers face these days are relatively easily overcome with a bit of web research. It’s rare that you come across something that someone else hasn’t already solved and blogged about online. This week, however, we had a problem that didn’t appear to have a readily available solution online, hopefully this blog post might help someone else that is searching for a similar solution.

Whilst putting together a web mapping application using the ESRI JavaScript API, we needed to be able to pull out the red, green and blue (RGB) components of the legend colours from a map layer. Some research revealed a few solutions in Visual Basic that could be run against ArcGIS Desktop, but we were after something we could run via the web, ideally from JavaScript. The ESRI API offers the esri.dijit.Legend class, which does a good job of pulling all the correct data from your map layer on ArcGIS Server and rendering a full legend on your page. However, it only offers startup(), refresh() and destroy() methods, with no way of picking the legend apart or interrogating its individual components. We figured that, in order to render the legend in HTML, ArcGIS Server must be making the information we wanted available to this class somehow.

The solution lies in the fact that ArcGIS Server makes all of this information available as part of one large layer description, in JSON format. This can be accessed over the web from your ArcGIS Server using the following URL:
http://<arcgis_server_name>/arcgis/rest/services/<folder>/<service>/MapServer/<layer>?f=json
which produces something like this

{"currentVersion":10.1,"id":0,"name":"CF1_ISISSoilMap","type":"Feature
 Layer","description":"","definitionExpression":"",
"geometryType":"esriGeometryPolygon","copyrightText":"",
"parentLayer":null,"subLayers":[],"minScale":0,"maxScale":0,
"drawingInfo":{"renderer":{"type":"uniqueValue","field1":
"Association_Symbol","field2":null,
"field3":null,"fieldDelimiter":", ","defaultSymbol":null,
"defaultLabel":null,"uniqueValueInfos":[{"symbol":{"type":"esriSFS"
...

At first this isn’t easily readable. Changing the URL parameter from f=json to f=pjson formats things a little better on the page, which helps:
http://<arcgis_server_name>/arcgis/rest/services/<folder>/<service>/MapServer/<layer>?f=pjson

{
 "currentVersion": 10.1,
 "id": 0,
 "name": "CF1_ISISSoilMap",
 "type": "Feature Layer",
 "description": "",
 "definitionExpression": "",
 "geometryType": "esriGeometryPolygon",
 "copyrightText": "",
 "parentLayer": null,
 "subLayers": [],
 "minScale": 0,
 "maxScale": 0,
 "drawingInfo": {
  "renderer": {
   "type": "uniqueValue",
   "field1": "Association_Symbol",
   "field2": null,
   "field3": null,
   "fieldDelimiter": ", ",
   "defaultSymbol": null,
   "defaultLabel": null,
   "uniqueValueInfos": [
    {
     "symbol": {
...

This might be fine for small amounts of JSON data, but still wasn’t that easy to navigate for the 3500 lines of text that was being output for the layer in question.

There are a number of excellent desktop and web based tools for making JSON data easier to read, a Google search for “JSON Viewer” will bring up a wide selection. One particular favourite of ours is http://jsonviewer.stack.hu/. Pasting the layer description data in, we were able to drill down into the various objects until we found exactly what we were looking for; the legend RGB values.

JSON visualiser

JSON visualiser

The section we’re interested in is:
JSON.drawingInfo.renderer.uniqueValueInfos
which is an array of each of the legend items. Each object in the array contains information on the legend label, style, colour and more. The red, green and blue component values that we were after are stored as the following, respectively:
JSON.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[0]
JSON.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[1]
JSON.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[2]

with JSON.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[3] holding an opacity value. All are integers from 0-255. In the examples above, i refers to the index of a particular legend item.

Other useful legend data include:
JSON.drawingInfo.renderer.uniqueValueInfos[i].label
JSON.drawingInfo.renderer.uniqueValueInfos[i].description

You could use the data above in a live JavaScript application to interrogate ArcGIS Server on the fly. Note that you should use the f=json parameter if you do this, for performance reasons. However, in this particular instance, we wanted to extract these values into a CSV file for storage in a database elsewhere. There was one small stumbling block that needed to be overcome and that was that not all legend items contained simple block colour, some were patterned or used repeated images instead of a plain colour fill. Luckily, the JSON data helped us filter these out by providing the following:
JSON.drawingInfo.renderer.uniqueValueInfos[i].symbol.type
For block colour legend entries, this variable is set to “esriSFS”. In this particular case, we were able to ignore any entries that weren’t equal to esriSFS.

Here is the JavaScript function for producing the required CSV. Note that this example makes use of the native JSON.parse() function which doesn’t work in some older versions of IE. For full browser compatibility, the DOJO and JQuery libraries offer suitable cross-browser alternatives.

function getRGB(){
  var XMLRequest = new XMLHttpRequest();
  var JSONURL = "<location of your JSON data>";
  XMLRequest.open("GET",JSONURL,false);
  XMLRequest.send();
  var retrievedJSON = XMLRequest.responseText;
  var retrievedObj;
  retrievedObj = JSON.parse(retrievedJSON);

  var myHTML = "Label,Red,Green,Blue<br />\n";
  for (var i=0;i<retrievedObj.drawingInfo.renderer.uniqueValueInfos.length;i++){
    myHTML += retrievedObj.drawingInfo.renderer.uniqueValueInfos[i].label;
    if (retrievedObj.drawingInfo.renderer.uniqueValueInfos[i].symbol.type == "esriSFS")
    {
      myHTML += "," + retrievedObj.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[0];
      myHTML += "," + retrievedObj.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[1];
      myHTML += "," + retrievedObj.drawingInfo.renderer.uniqueValueInfos[i].symbol.color[2];
    }
    myHTML += "<br />\n";
  }
  document.getElementById("RGBValues").innerHTML = myHTML;
}

With the following <div> required further down in the <body> of the page:

<div id="RGBValues">
  RGB Values to go here - something went wrong if you can see this.
</div>

The output looked something like this, which was copied and pasted into Excel for tweaking and then imported into our database.

CSV data output to browser

CSV data output to browser