Each new major version has managed to improve the performance and support features that were available only to native devices before. PhoneGap has come so far that most of the basic needs for a mobile application can be achieved with it, without writing a single line of code in the native language.
In this chapter, we will cover the following sections:
A brief history
What is PhoneGap?
Setting up a local development environment
Let's get started with a quick introduction to PhoneGap.
In 2007, Apple introduced its first smartphone: the iPhone. It changed the mobile phone industry forever. iPhone was the first smartphone that provided a browsing experience comparable to desktop web browsing. Many web pages were trying to mimic iPhone's look and feel for mobile use. Originally, iPhone didn't support third-party native apps. Many tried to create hybrid applications by hosting them on web servers. The application was running inside the Safari browser.
PhoneGap was started as a project at the iPhoneDevCamp event in 2008. It was started by a team of developers wanting to simplify cross-platform mobile development. Until then, it was easy to create applications for a single platform but there was no tool to manage it for multiple platforms. In the beginning, the idea was to create project templates that could be reused inside Xcode for iOS or Eclipse for Android to develop hybrid applications. Shortly afterwards, PhoneGap supported Blackberry OS. The team behind the project was from Nitobi Software company. They started to work on PhoneGap as a more serious tool for development. It began to be used for a full development cycle including preparing builds for deployment to the app stores or for using inside enterprises. PhoneGap won the People's Choice Award at O'Reilly Media's 2009 Web 2.0 Conference. Prior to Apple's developer license agreement version 4.0, the rules for submitting PhoneGap applications to the Apple app store were not clear and many apps were rejected for that reason. After updating the developer license agreement, Apple has confirmed that the framework has been approved for submitting PhoneGap applications.
In 2011, there were two important items of news for PhoneGap development. Adobe decided to acquire Nitobi Software as a part of the strategy for moving away from Adobe Flash on mobile devices. The other news was that they were going to open source PhoneGap and contribute it to the Apache Foundation. Since being contributed to the Apache Foundation, it changed to Apache Callback, Apache DeviceReady, and finally Apache Cordova (http://cordova.apache.org). After Adobe acquired it, the team behind PhoneGap worked full time on the project and the updates are being delivered on a monthly basis.
The PhoneGap brand has been preserved by Adobe. PhoneGap is now a fork of Apache Cordova with some extra features. PhoneGap and Cordova were basically identical until the release of version 2.x. After that, the development went into simplifying project creation. A command-line interface was created for most common actions, and the core features were separated into numerous plugins. The new process simplified the creation and installation of new plugins.
In short, PhoneGap (http://www.phonegap.com/) is a distribution of Cordova. Cordova is an open source mobile framework that gives an alternative to native development and the existing application is reusable on other platforms with little or no modification to the code.
With PhoneGap, any web developer can start developing mobile applications with no need to learn additional skills, apart from learning about PhoneGap's command-line interface (CLI) commands and PhoneGap's API. In a matter of hours, you can create a working prototype that can be tested directly on the user's smartphone, or built and deployed to the app store as a normal native application in all major application stores (iTunes app store, Android Apps on Google Play, Amazon Appstore, and Windows Store).
PhoneGap can be used to target support for multiple platforms from day one without needing to have another developer for another technology stack. Currently it supports the following major platforms:
Google Android (http://developer.android.com/index.html)
Microsoft Windows Phone (http://msdn.microsoft.com)
Blackberry 10 (https://developer.blackberry.com/)
As PhoneGap is already a stable framework and is constantly evolving, there are a lot of features that were previously available only for native applications but that can be used now inside PhoneGap. Let's list some of the major features that are being supported by the latest PhoneGap version:
Events sent from the native environment
Multi-language support and localization
In AppBrowser, the ability to run another browser view inside the PhoneGap application
Most of these features are available through calling native methods, but as HTML5 is progressing, many of these features are available through native web view HTML5 method calls, thus removing dependency on the native code. If you want to see what features are supported with HTML5, you can take a look at this page (http://html5please.com/). It shows support for the various mobile browsers.
It is not a solution that fits all needs. It depends on the features and utility of the application, which can determine if PhoneGap is fit for its needs. If you are looking to develop a graphic-intensive 3D game or application that needs to use all the processing power the device has, then probably it is not the best choice to start with. PhoneGap can easily be used for all applications that do not involve a lot of animations or complicated transitions that are not easily achieved inside the HTML and CSS environment.
Here we will take a look at four different solutions that all have advantages and disadvantages:
jQuery Mobile (http://jquerymobile.com/)
A lot of plugin support
No official paid support
Based on jQuery
Great tools, such as Theme Roller and Codiqa UI builder
Sencha Touch (http://www.sencha.com/products/touch/)
No default UI
Access to native functions
Limited access to more advanced features without additional plugins
It seems that there is a lot of confusion between these two because they share the same history and their paths diverged only recently. From the beginning the project was called PhoneGap, but once Adobe bought the company behind it, it decided to open source the majority of the code while keeping the name for its use and giving a new name (Cordova) to the open source project.
Since then, PhoneGap has been built on top of the Cordova project with some additional libraries and tighter integration with other PhoneGap tools and services; the most prominent for PhoneGap developers is PhoneGap Build, which we will go into in greater detail in the next chapter.
There is not much difference for the beginner between PhoneGap and Cordova, apart from the ability to build native applications for all major platforms from any operating system with the help of PhoneGap Build. This makes it more useful in some cases since the majority of people do not like switching from their favorite operating system.
Since this book covers all major operating system platforms, before we start to learn more about PhoneGap and its useful features we need to prepare the development environment. The PhoneGap website (http://phonegap.com/install/) has instructions on how to install it, which should be fairly easy to achieve. However, in reality, each platform requires us to install additional libraries and simulators to be able to run them for different mobile platforms.
There are two ways to develop PhoneGap applications. Until PhoneGap introduced the command-line interface (CLI), the only way was to develop plugins for the integrated development environment (IDE), such as Xcode or Eclipse. With the introduction of the CLI, it was possible to develop PhoneGap mobile applications with PhoneGap SDK inside your favorite text editor or integrated developer environment. In this book, we are going to use the latter option; since most developers have different opinions about editors, it is better to stay neutral on this topic.
However, for this book I will be using Sublime Text 3 (http://www.sublimetext.com/3), a plain text editor that is one of the most popular choices nowadays and has numerous plugins and extensions to work with. Since it supports Windows, Mac OS, and Linux, it won't be included in the installation process for a specific operating system. On the provided link, you can download the text editor and install it with the provided information. Sublime Text 3 can be used for free for as long as you like (you will be prompted to buy it from time to time); this is a fully working editor without any limits. But I would strongly advise you to get the full version and support the people behind it since they have done a great job and it only costs $70 and doesn't have restrictions on the number of machines for a single user.
There is a great free alternative to Sublime Text called Atom editor, which is open source and available at the following page: https://atom.io/. It will be sufficient to do the work but it doesn't come with lot of plugins like Sublime Text.
In the following pages, there will be instructions on how to cover the installation process for the three most popular operating systems that developers are using: Windows, Mac OS, and Ubuntu. For other Linux distributions, it should not be too hard to adapt the Ubuntu installation process, especially if you are using Debian. Let us get started.
The easiest way to install the various Unix tools and open source software onto Mac OS X is via a package manager but unfortunately OS X does not come with one; however, there are some alternatives that we can use instead. We are going to use Homebrew (http://brew.sh/).
If you already have your own package manager preference or you want to compile it from the source code, you are encouraged to use the latest version for the library.
Before installing Homebrew, we need to install Xcode (https://itunes.apple.com/au/app/xcode/id497799835?mt=12) so we can build and run applications in the iOS simulator:
To install the Xcode component, perform the following steps:
Download the image and then drag the
Xcodeicon into the
Applicationsfolder. Before proceeding with the next step, you need to open Xcode and agree to the license, as it needs to install additional components:
After the components are installed, you need to install the Xcode command line tools with the following command:
This will open the following prompt to install the required tools. Select Install to install the required libraries, and wait until everything is successfully installed:
To download and install Homebrew, run the following installation script on the command line. It will ask you for a few details before proceeding, but you can leave the default values in use, unless you have a specific reason to change them, then wait for the script to finish:
ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
After successful installation of Homebrew, please run the following command to check if the installation was successful:
Before installing any additional libraries through Homebrew, let us run
updateto get a list of the latest versions of the libraries:
Since PhoneGap is a Node.js application, we will need to install a working version of Node.js. With Homebrew, the process of installing additional libraries is easy; just run the following command:
brew install node
brew install android-sdk
At the end of the file, add the following line:
export ANDROID_HOME=`brew --prefix android`
Save and close the file and run the following to reload the newest updates:
The following command will launch the Android SDK manager window and you should see the recommended libraries already preselected:
When it's finished, quit the Android SDK Manager application.
Besides Android SDK, we need to install Apache Ant in order to be able to build and run the applications inside Android Simulator. Run the following command:
brew install ant
This will launch the Android Virtual Device Manager. Click the Device Definitions tab and select a sample device. From the list select the Nexus 5 profile, and press the Create AVD button as shown in the following screenshot:
Close the Android Virtual Device Manager window.
Next we need to install the required libraries (to be able to build and run applications in the iOS simulator) by installing the Node.js library to control the iOS simulator directly from the command line:
sudo npm install -g ios-sim
When all the required libraries and tools are installed, install PhoneGap with the following command:
sudo npm install -g PhoneGap
To verify we can build and launch applications in both simulators, let us create and run a quick sample application by running the following command:
PhoneGap create hello com.example.hello HelloWorld cd hello
This creates a basic sample application. Next we need to verify it works on the Android and iOS simulator.
For iOS we need to open the iOS simulator and run the application. Run the following command:
phonegap run ios --emulator
phonegap run android —emulator
Linux is well known for having multiple distributions that have different ways of installing new libraries on it. For this book, we are going to use one of the most popular distributions: Ubuntu. Ubuntu is built on top of Debian so installing on both of them shouldn't be much different. As for the other distributions, it shouldn't be too hard to adapt the following commands for these environments. Perform the following steps:
First we need to fully update Ubuntu to avoid any issues while installing the required libraries:
sudo apt-get update sudo apt-get install build-essential
Next we install some libraries that are required to finish the installation:
sudo apt-get install python-software-properties python g++ make
Since PhoneGap is a Node.js application, we will need to install the latest working version of Node.js. Make sure you install Node.js and not node, which is a different library:
sudo apt-get install nodejs
While that's all you need to do to install Node.js, there is a small detail that you need to take care of. When Ubuntu installs the package, it names the Node.js executable
nodejs. The problem is that many applications, including PhoneGap, expect the executable to be named node. To fix this inconsistency, simply create a symlink named node that points to Node.js as follows:
sudo ln -s /usr/bin/nodejs /usr/bin/node
Next we need to install additional libraries for Node.js:
sudo apt-get install npm
Finally, we can install the PhoneGap library by running the following command:
sudo npm install -g phonegap
sudo apt-get install ant
Since Android uses the Java language, we will need to install Java JRE and Java JDK, which supports it:
sudo apt-get install openjdk-7-jre sudo apt-get install openjdk-7-jdk
Now it is time to install the actual Android SDK. Run the following command:
wget http://dl.google.com/android/android-sdk_r24.0.2-linux.tgz tar zxvf android-sdk_r24.0.2-linux.tgz
Let us move the content of the Android SDKs to a more appropriate location:
sudo mv android-sdk-linux/ /opt/android/
Now we need to set up paths to be executable from anywhere inside the terminal. Let us open the
Enter the following lines at the end of the file:
export ANDROID_HOME="/usr/local/android-sdk-linux/tools" export ANDROID_PLATFORM_TOOLS="/usr/local/android-sdk-linux/platform-tools" export PATH="$PATH:$ANDROID_HOME:$ANDROID_PLATFORM_TOOLS"
To use the command in the same terminal, you need to run the following command:
Now that we have set up the Android SDK environment, we need to run the configuration application to download the required libraries and emulators. Run the following command:
Execute Android from the shell. This is a good first test to make sure you've done everything right up to now. If you get an error, rerun through the preceding steps and make sure that you've installed all the requirements and added your environment variables correctly.
If there is no error, you should see that executing Android opens up a kind of package manager that you can use to install different Android components. By default, a certain number of these will be pre-selected for installation. Leave them as is and, in addition, tick the box next to the entry named API 4.4.2 (API 19). Once you've done that, download and install everything by accepting the license, as shown in the following screenshot:
The last step before trying it out is to create an Android emulator that will emulate a working Android device on your computer. By default no emulator is set, so we need to set it manually by running the following command:
phonegap create hello com.example.hello HelloWorld cd hello
To verify everything is working fine, you need to run the emulator:
phonegap run android —emulator
If you want to develop and test applications for Windows phones, you will need to have a working Windows computer to hand because you can only run them there.
There are multiple versions of the Windows operating system but it should be fairly easy to use any of them by carrying out the following instructions, since most of the libraries and applications are available as an installer. Thus, you can simply go ahead with the installation process and the only thing you need to do manually is to set the environment variables to be reachable from any command prompt.
The easiest way is to create a
Development directory in your home directory (
C:\Users\yourusername\Development). For ease, you might want to drag that folder into the
Favorites list in Explorer, too. We will add all the source code we work on to the examples there.
Download the latest available version that works on your computer from http://www.oracle.com/technetwork/java/javase/downloads/index.html.
Run the downloaded file and go through the following steps:
You need to make sure that you have the following paths set in your Advanced System Properties Environment Variables.
You need to set the path to be visible so it can be run as a command from the command prompt. Navigate to Control Panel | System and Security | System. There you need to click on the Advanced tab, as shown in the following screenshot:
You will need to press the Environment Variables button and update system variables with the following data:
Create a new system variable:
Pathand add the following value
Add the preceding line at the end of the remaining paths and make sure it is preceded by a
;(semicolon). It is important not to forget it:
In the command prompt, if you see the regular Java help text printout response then the Java environment is all set. Close the command prompt.
Next we need to download Android SDK for Windows, which is available as an automated installer. Download the latest SDK version from: https://developer.android.com/sdk/index.html.
Make sure you do not use the default proposed folder since you might have some problems with accessing folder content in the following steps. Instead, set the installation location to
We now need to go back to add an additional environment variable in the Android SDK location as we did before for Java SDK.
First we add a new system variable:
Pathand append additional value
Again, do not forget to add a
;(semicolon) at the beginning.
Next we need to open another command prompt to check whether it is installed properly. Run the following command:
This will open the Android SDK Manager, where we will need to select which Android version to download; this is going to be used inside the emulator:
After selecting the packages ticked in the screenshot, you need to click Install 7 packages and wait until they are installed.
We need to install the
git command (used for many libraries) and later plugins that we will require to make it work with PhoneGap. Perform the following steps:
Download and install the git installer from http://git-scm.com/download/win.
You should open the installer, follow the instructions, and select the predefined values. After installation, repeat the same process with system variables and add the variable
GIT_HOMEwith a value
C:\Program Files\git. Add additional information to the existing
Again, to test whether it is working, run the
gitcommand in the newly opened command prompt.
Ant is a tool that is required by Android to build all the code into the Android application package. You need to download and install Ant from: http://www.us.apache.org/dist/ant/binaries/. Select the latest version that has the .zip extension.
Unzip the content into the folder
Again set the system variables with the creation of a new variable
ANT_HOMEwith the value
C:\Android\apache-ant-1.9.4. Update the existing
In the next step, we will install the latest version of Node.js from the http://nodejs.org as an installer. After it is downloaded, run the downloaded file, which will guide you through the process. The Installer should set all the path variables you need to run it. To confirm the installation worked, run the
nodecommand in the command prompt. It will open the node console, which you can close by pressing Ctrl + C twice.
npm install -g phonegap
To verify we have installed PhoneGap properly, we simply run the
phonegapcommand at the command prompt; this should return details about PhoneGap.
There is one last thing we need to do before running the test project. We need to create Android Emulator Start by running the following command:
By default, there are no emulators, so we need to create one before starting. Press Create… which will open a window to create a new emulator. Enter the following settings and press OK:
A new emulator should be listed. Close the application.
To verify we can build and launch the application in the simulator, let us create and run a quick sample application by running the following command:
phonegap create hello com.example.hello HelloWorld cd hello
To test that everything is working well, we are going to run the following command that should run Android Device Simulator, as selected before:
phonegap run android —emulator
You should see it running an example.
In this introductory chapter we covered a lot. We got a quick overview of what, as a framework, PhoneGap is and is not. Before we start to do any real work with PhoneGap, we need to have installed all the required tools that we covered in this chapter in detail, for all three major platforms.
After finishing this chapter, you should have a fully functional setup to start developing PhoneGap applications on your favorite operating system.
In the next chapter, we will cover the support for different platforms and the features that each platform supports. We will come to understand what PhoneGap Build is and how to test usability on native devices.