Integrating Firebase Into Our Application

Integrating Firebase into our application from the Course AngularJS: Adding Registration to Your Application.


Authentication is a fundamental part of any web application, but it can be notoriously difficult to implement. In this short course, you’ll create a simple registration system that allows users to log in and out of your applications. By taking advantage of Google’s Firebase authentication service, you can manage registrations easily and securely. In the process, you’ll explore working with the AngularJS application structure (including routes and controllers), storing user information into the Firebase NoSQL database, and creating services to manage registration information throughout different controllers. This will help you create a great registration template that you can use as a starting point in a variety of web applications.

Topics include:

  • Adding a basic MVC structure
  • Using routes
  • Processing form input
  • Integrating Firebase
  • Storing registration information in the database
  • Logging users in and out of an app

Realtime Database

Firebase provides a realtime database and backend as a service. The service provides application developers an API that allows application data to be synchronized across clients and stored on Firebase’s cloud. The company provides client libraries that enable integration with Android, iOS, JavaScript, Java, Objective-C and Node.js applications. The database is also accessible through a REST API and bindings for several JavaScript frameworks such as AngularJS, React, Ember.js and Backbone.js. The REST API uses the Server-Sent Events protocol, which is an API for creating HTTP connections for receiving push notifications from a server. Developers using the realtime database can secure their data by using the company’s server-side-enforced security rules.


A web API is a subset of an application programming interface (API). It is used for exchanging information with a website, either by receiving or by sending data. A web API typically consists of multiple publicly exposed endpoints that accept HTTP requests and respond with the requested data, typically in the form of JavaScript Object Notation (JSON) or Extensible Markup Language (XML).



A server-side web API is a programmatic interface to a defined request-response message system, typically expressed in JSON or XML, which is exposed via the web—most commonly by means of an HTTP-based web server. Mashups are web applications which combine the use of multiple such web APIs. Webhooks are server-side web APIs that take as input a URI that is designed to be used like a remote named pipe or a type of callback such that the server acts as a client to deference the provided URI and trigger an event on another server which handles this event thus providing a type of peer-to-peer IPC.


A client-side web API is a programmatic interface to extend functionality within a web browser or other HTTP client. Originally these were most commonly in the form of native plug-in architectures however most newer ones target standardized JavaScript bindings.

The Mozilla Foundation created their WebAPI specification which is designed to help replace native mobile applications with HTML5 applications.

Google created their Native Client architecture which is designed to help replace insecure native plug-ins with secure native sandboxed extensions and applications. They have also made this portable by employing a modified LLVM AOT compiler.

See More Resources:

Free eBook: AngularJS Programming Cookbook
Responsive Web Design with AngularJS
Firechat – Open-source real-time chat, built on Firebase
Firepad – Open source collaborative code and text editing

Build My Site

Creating and Compiling a Hello World Application with Go

Creating and compiling a hello world application provides you with in-depth training on Developer. Taught by David Gassner as part of the Up and Running with Go developer series.

What is Go? Go is a next-generation, open-source programming language created by Google for building systems, web, and other applications. This course is designed to help developers get started with Go, covering its core language elements and syntax. David Gassner introduces tools and skills used in a Go workflow—including Go Playground, an online tool that takes Go development off the desktop. He also covers basic programming tasks: managing values, using math operators, storing values as complex types, and managing program flow. Plus, learn how to structure Go code for maximum readability and performance, read and write files, and make simple web requests.

Topics include:

  • Installing Go tools
  • Creating and compiling a Go workspace
  • Exploring variables, constants, and types
  • Storing ordered and unordered values
  • Grouping related values in structs
  • Programming conditional logic and loops
  • Defining and calling functions
  • Handling errors
  • Working with files
  • Creating a simple HTTP server

Language Tools in Go

Go includes the same sort of debugging, testing, and code-vetting tools as many language distributions. The Go distribution includes, among other tools,


  • go build, which builds Go binaries using only information in the source files themselves, no separate makefiles
  • go test, for unit testing and microbenchmarks
  • go fmt, for formatting code
  • go get, for retrieving and installing remote packages
  • go vet, a static analyzer looking for potential errors in code
  • go run, a shortcut for building and executing code
  • godoc, for displaying documentation or serving it via HTTP
  • gorename, for renaming variables, functions, and so on in a type-safe way
  • go generate, a standard way to invoke code generators

Here is a Hello world program in Go:

package main

import "fmt"

func main() {
fmt.Println("Hello, World")

Run or edit this example online.

It also includes profiling and debugging support, runtime instrumentation (to, for example, track garbage collection pauses), and a race condition tester.

Conventions and Code Style

The Go authors and community put substantial effort into molding the style and design of Go programs:

  • Indentation, spacing, and other surface-level details of code are automatically standardized by the go fmt tool. golint does additional style checks automatically.
  • Tools and libraries distributed with Go suggest standard approaches to things like API documentation (godoc), testing (go test), building (go build), package management (go get), and so on.
  • Syntax rules require things that are optional in other languages, for example by banning cyclic dependencies, unused variables or imports, and implicit type conversions.
  • The omission of certain features (for example, functional-programming shortcuts like map and C++-style try/finally blocks) tends to encourage a particular explicit, concrete, and imperative programming style.
  • Core developers write extensively about Go idioms, style, and philosophy, in the Effective Go document and code review comments reference, presentations, blog posts, and public mailing list messages.

Build My Site

Building a Note-Taking App for Android | Customizing the appearance of list items

Android, Windows, and iOS support are all required for a successful product. This course, revised for 2015, is one in a series that will demonstrate the platforms’ similarities and differences via the development of a complete note-taking app. This installment uses Android Studio to get the job done. Author David Gassner shows you how to create a new project in Android Studio, customize its material design themes, and create a data management layer that allows users to create, read, update, and delete notes. He also demonstrates how to build a rich user interface, create activities (aka screens), and enable action icons to control navigation.

Building a Note-Taking App for iOS 8 and Building a Note-Taking App for Windows Phone 8 and Windows Store use the same assets to develop a similar app. Compare and contrast the steps and discover the similarities and differences between the three platforms. See more about this course: Building a Note-Taking App for Android.

Topics include:

  • Understanding Android UI and data management patterns
  • Creating an Android Studio project
  • Customizing material design theme colors
  • Defining an SQLite database structure
  • Managing data with ContentProvider and Loader classes
  • Retrieving and displaying data
  • Customizing data display with a CursorAdapter
  • Creating, updating, and deleting notes
  • Preparing the app for deployment

Material Design

Material Design (codenamed Quantum Paper) is a design language developed by Google. Expanding upon the “card” motifs that debuted in Google Now, Material Design makes more liberal use of grid-based layouts, responsive animations and transitions, padding, and depth effects such as lighting and shadows. Designer Matías Duarte explained that, “unlike real paper, our digital material can expand and reform intelligently. Material has physical surfaces and edges. Seams and shadows provide meaning about what you can touch.” Google states that their new design language is based on paper and ink.

Some typical Material Design UI components

Material Design can be used in Android version 2.1 and up via the v7 appcompat library, which is used on virtually all Android devices that were made after 2009. Material Design will gradually be extended throughout Google’s array of web and mobile products, providing a consistent experience across all platforms and applications. Google has also released application programming interfaces (APIs) for third-party developers to incorporate the design language into their applications.

Google announced Material Design on June 25, 2014, at the 2014 Google I/O conference. As of 2015, most of Google’s mobile applications for Android have applied the new design language, including Gmail, YouTube, Google Drive, Google Docs, Sheets and Slides, Google Maps, Inbox, all of the Google Play-branded applications, and to a smaller extent the Chrome browser and Google Keep. The desktop web interfaces of Google Drive, Docs, Sheets, Slides and Inbox have incorporated it as well.


The canonical implementation of Material Design for web application user interfaces is called polymer paper elements. It consists of the Polymer library, a shim that provides a Web Components API for browsers that do not implement the standard natively, and the so-called “paper elements collection”.

See more resources:

Material Design Resources and Inspiration
Material Design Lite – A Giant Library of Web Components
Lessons Learned From Analyzing Material Design Components

Build My Site

Building the Node.js Server App

Socket technology is a natural fit for presentation and chat applications. This course helps you use Socket IO in combination with powerful JavaScript libraries to develop an interactive polling application that processes data in real time, allowing presenters to interact with audience members and graph their responses. Alex Banks shows each step in the process, starting with setting up the node environment and express app for development. You’ll then create and connect sockets for real-time data sharing and set up routing and interface elements with React.js, refactoring those components for ES6 integration. This setup will allow you to program functionality for running presentations, joining presentations, asking and answering questions, and graphing the results of the poll. See more: Building a Polling App with Socket IO and React.js.

Topics include:

  • Setting up the environment
  • Connecting sockets
  • Handling disconnects
  • Setting up the React.js router
  • Passing state to child components as properties
  • Joining the presentation
  • Starting and running the presentation
  • Asking and answering questions
  • Graphing results
  • Upgrading to ES6


Node.js allows the creation of web servers and networking tools using JavaScript and a collection of “modules” that handle various core functionality. Modules handle file system I/O, networking (HTTP, TCP, UDP, DNS, or TLS/SSL), binary data (buffers), cryptography functions, data streams, and other core functions. Node’s modules use an API designed to reduce the complexity of writing server applications.

Frameworks can be used to accelerate the development of applications, and common frameworks are Express.js, Socket.IO and Connect. Node.js applications can run on Microsoft Windows, Unix, NonStop and Mac OS X servers. Node.js applications can alternatively be written with CoffeeScript (an alternative form of JavaScript), Dart or Microsoft TypeScript (strongly typed forms of JavaScript), or any language that can compile to JavaScript.

Smashing Node.js: JavaScript Everywhere–Free Sample Chapters


Node.js is primarily used to build network programs such as web servers, making it similar to PHP and Python. The biggest difference between PHP and Node.js is that PHP is a blocking language, where commands execute only after the previous command has completed, while Node.js is a non-blocking language where commands execute in parallel, and use callbacks to signal completion.

Node.js implements event-driven programming for web applications in JavaScript. Developers can create highly scalable servers without using threading, by using a simplified model of event-driven programming that uses callbacks to signal the completion of a task. Concurrency is difficult in many server-side programming languages, and often leads to poor performance. Node.js is designed to use the scripting language JavaScript for Unix network programming.

Thousands of open-source libraries have been built for Node.js, most of which are hosted on the npm website. Its developer community has two main mailing lists and the IRC channel #node.js on freenode.

See more resources:

private npm is here
Node.js – A Simple Tutorial With Example
node.js domains make my app predictably fixable

Build My Site

Debugging the Web: JavaScript

Using a debugger provides deeper insights into your code, telling you not just when things don’t work but also why. Best of all, the tools are easy to learn and often built right into your web browser. In this course, Joe Chellman looks at how to find and fix issues in JavaScript projects using a debugger, the tool of the trade. He reviews the different software available and introduces core debugging techniques, such as inspecting variables and stepping through functions. In the last half of the course, Joe debugs four types of real-world JavaScript scenarios (a jQuery plugin, WordPress theme, mobile site, and AngularJS project) and touches on how incorporating test-driven development practices into your debugging process can increase your productivity and the strength of your code. See more: Debugging the Web: JavaScript.

Topics include:

  • Getting the browsers and plugins
  • Leveraging the Console API
  • Using breakpoints
  • Using step functions
  • Watching variables
  • Debugging jQuery, WordPress, mobile sites, and more

Debugging Tools

A debugger or debugging tool is a computer program that is used to test and debug other programs (the “target” program). Within JavaScript, access to a debugger becomes invaluable when developing large, non-trivial programs. Because there can be implementation differences between the various browsers (particularly within the Document Object Model), it is useful to have access to a debugger for each of the browsers that a Web application targets.

Script debuggers are integrated within Internet Explorer, Firefox, Safari, Google Chrome, Opera and Node.js.


In addition to the native Internet Explorer Developer Tools, three debuggers are available for Internet Explorer: Microsoft Visual Studio is the richest of the three, closely followed by Microsoft Script Editor (a component of Microsoft Office), and finally the free Microsoft Script Debugger that is far more basic than the other two. The free Microsoft Visual Web Developer Express provides a limited version of the JavaScript debugging functionality in Microsoft Visual Studio. Internet Explorer has included developer tools since version 8 (reached by pressing the F12 key).

In comparison to Internet Explorer, Firefox has a more comprehensive set of developer tools, which include a debugger as well. Old versions of Firefox without these tools used a Firefox addon called Firebug, or the older Venkman debugger. Also, WebKit’s Web Inspector includes a JavaScript debugger, which is used in Safari. A modified version called Blink DevTools is used in Google Chrome. Node.js has node-inspector, an interactive debugger that integrates with the Blink DevTools, available in Google Chrome. Last but not least, Opera includes a set of tools called Dragonfly.

In addition to the native computer software, there are online JavaScript IDEs, debugging aids are themselves written in JavaScript and built to run on the Web. An example is the program JSLint, developed by Douglas Crockford who has written extensively on the language. JSLint scans JavaScript code for conformance to a set of standards and guidelines. Many libraries for JavaScript, such as three.js, provide links to demonstration code that can be edited by users. They are also used as a pedagogical tool by institutions such as Khan Academy to allow students to experience writing code in an environment where they can see the output of their programs, without needing any setup beyond a web browser.

See more resources:

Eloquent JavaScript by Marijn Haverbeke — a free, Creative Commons–licensed eBook
Douglas Crockford Lectures on JavaScript
Codeacademy’s JavaScript Track

Build My Site

Building a Data-Driven App with AngularJS | Creating Your First Controller

Want to create web applications that can handle multiple users, registration, and real-time data? With these AngularJS tutorials, you’ll be quickly building apps with advanced features like these. Ray Villalobos starts the course with a Git, Node.js, and GitHub setup that will get you off on the right foot. Next, learn how to create your first controller, connect a Firebase database, and read, push, and delete data from that database. Ray then shows you how to set up user registration with Firebase’s simpleLogin service, so you can log users in and out and pass registration data back and forth from the app. With a few finishing touches, like custom directives, your Angular app will be ready to publish. Watch more: Building a Data-Driven App with AngularJS.

Note: This course was revised in March 2015 to reflect changes to Firebase’s database and simpleLogin services.

Topics include:

  • Installing Git and Node.js on Mac or Windows
  • Installing AngularJS and its models
  • Creating modules and routes
  • Working with controllers
  • Connecting to Firebase data
  • Adding user registration
  • Searching, filtering, and deleting records
  • Creating custom directives



Controllers are the middleman between the Model and the View, they drive the Model and View changes. Imagine that the controller is given some html from the route and a Javascript object from the dependency injection; with these two things, the controller will tell the view (the html) what it can do by giving it scope variables and maybe a few functions.


Let’s take a peek at what a Controller looks like.

A good Controller will have as little logic in it as possible, and should only be used for two things: Binding the Model to the View (initializing the View) and adding helper functions to the View.

app.controller('InboxCtrl', function () {
              // Model and View bindings
	     // Small helper function not needed anywhere else

If you go through the Angular documentation examples (available at you’ll notice Model data being declared in the Controller. While this is okay for examples, the Controller easily becomes the Model as well – which is very bad for many reasons:

  • All the pieces start to get more coupled together
  • More difficult to share business logic
  • Makes things difficult to test

Remember: A good Controller will have as little logic in it as possible.

Each controller has access to a $scope and some html. $scope is the most documented way of adding properties and methods to our view. Remember how we said each ‘ng-controller’ attribute specifies a scope of HTML to manage? Well, that scope has access to the same $scope as the Controller function.

Note: $scope isn’t the only way to pass data to the front end. Many developers use a combination of the “Controller As” configuration options along with the this keyword. For the purpose of this tutorial, we will stick with $scope as it’s been around for much longer than ‘Controller As’.

app.controller('InboxCtrl', function ($scope) {
	// initialize the title property to an array for the view to use
	$scope.title = "This is a title";

Note: Notice we’re injecting $scope inside the function.

We can then use this like so:

<div ng-controller="InboxCtrl">
	{{ title }}

Note: Here we’re accessing the title directly, however it is encouraged to always have at least one dot (.) in our view expression properties. Using the “controller as” with this syntax would solve this giving us the . like so . More info here.

In order to keep our controllers more reusable, we would hook up data in our controller via a Factory or Service.

See more resources:

Understanding Backbone and other Model-View-Controller (MVC) Libraries
Installing AngularJS, plus modules
Realtime AngularJS Pub/Sub Messaging using PubNub

Build My Site

Developing for the MEAN Stack and MongoDB – Using the Cloud9 Platform

The MEAN stack is a collection of tools for building robust web applications with JavaScript. It includes four main ingredients: MongoDB, ExpressJS, AngularJS, and Node.js. In this course, Michael Sullivan shows you what it “means” to develop on the MEAN stack, walking through setup, user authentication and security, routing, controller and view creation, data storage, and more—all the way up to app deployment. By the end of the course, you’ll have a clear picture of the MEAN stack workflow and its many advantages, including enhanced performance and the convenience of using a single programming language across every layer of your application. See more: Developing for the MEAN Stack and MongoDB

Topics include:

  • Getting your Node.js development environment set up
  • Creating an Express application
  • Configuring user authentication and strong password hashing
  • Accessing MongoDB collections in the shell and with Mongoose
  • Building a mini SPA (single-page application) with AngularJS
  • Adding custom form validation with AngularJS
  • Deploying an app to Heroku


Cloud9 IDE

Cloud9 IDE is a freeware online integrated development environment. It supports more than 40 programming languages, including PHP, Ruby, Python, JavaScript with Node.js, and Go. It enables developers to get started with coding immediately with pre-setup workspaces, collaborate with their peers with collaborative coding features, and web development features like live preview and browser compatibility testing.

It is written almost entirely in JavaScript, and uses Node.js on the back-end. The editor component uses Ace. As of July 2014, it uses Docker containers for its workspaces, and is hosted on Google Compute Engine.


The MEAN Stack:

MongoDB is a cross-platform document-oriented database. Classified as a NoSQL database, MongoDB eschews the traditional table-based relational database structure in favor of JSON-like documents with dynamic schemas (MongoDB calls the format BSON), making the integration of data in certain types of applications easier and faster. Released under a combination of the GNU Affero General Public License and the Apache License, MongoDB is free and open-source software.

Express.js is a Node.js web application framework, designed for building single-page, multi-page, and hybrid web applications.

AngularJS, commonly referred to as Angular, is an open-source web application framework maintained by Google and a community of individual developers and corporations to address many of the challenges encountered in developing single-page applications. Its goal is to simplify both development and testing of such applications by providing a framework for client-side model–view–controller (MVC) architecture, along with components commonly used in rich internet applications.

Node.js is an open source, cross-platform runtime environment for server-side and networking applications. Node.js applications are written in JavaScript, and can be run within the Node.js runtime on OS X, Microsoft Windows, Linux, FreeBSD, and IBM i. Node.js provides an event-driven architecture and a non-blocking I/O API that optimizes an application’s throughput and scalability. These technologies are commonly used for real-time web applications.

See more resources:

Creating controllers and views in AngularJS
Single page Application with Angularjs, Minimalweb Node MVC and MongoDB
Delving into Node.js and Express web framework

Build My Site

Tracking our navigation with ScrollSpy and jQuery

Find out how Bootstrap can transform your standard HTML websites into inspired single-page designs. This course is a project-based approach to learning how to manipulate website layouts with the Bootstrap framework. Staff author Ray Villalobos tackles Bootstrap’s layout classes, like containers, rows, and columns, and shows what it takes to customize Bootstrap’s CSS and address layout challenges like multiple grids and columns. Plus, learn how to track navigation as users scroll, with the ScrollSpy plugin, and create a full-screen, responsive image carousel. See more at: Bootstrap Layouts: Responsive Single-Page Design.

Topics include:

  • Analyzing your markup
  • Creating simple column layouts
  • Creating basic navigation and a simple carousel
  • Modifying Bootstrap styles
  • Working with branding and toggle styles
  • Adding interactivity

Uses for Bootstrap

To use Bootstrap in an HTML page, the developer downloads the Bootstrap CSS stylesheet and includes a link in the HTML file.

(The developer can also compile the CSS file from the downloaded Less or Sass stylesheets, with a special compiler.)

If the developer wants to use the JavaScript components, they must be referenced along with the jQuery library in the HTML document.

The following example illustrates how this works. The HTML code defines a simple search form and a list of results in tabular form. The page consists of HTML 5 elements and CSS information according to the Bootstrap documentation.

A view of the example using Bootstrap, rendered in Google Chrome
<!DOCTYPE html>
    <title>Example of Twitter Bootstrap</title>
    <!-- Include the bootstrap stylesheets -->
    <link href="" rel="stylesheet">
    <div class="container">
      <label>Example for a simple search form.</label>
      <!-- Search form with input field and button -->
      <form class="well form-search">
        <input type="text" class="input-medium search-query">
        <button type="submit" class="btn btn-primary">Search</button>
      <!-- Table with alternating cell background color and outer frame -->
      <table class="table table-striped table-bordered">
            <td>Lorem ipsum dolor ...</td>
            <td>Ut enim ad minim veniam, ...</td>
            <td>Duis aute irure dolor ...</td>
    <!-- JavaScript placed at the end of the document so the pages load faster -->
    <!-- Optional: Include the jQuery library -->
    <script src=""></script>
    <!-- Optional: Incorporate the Bootstrap JavaScript plugins -->
    <script src=""></script>
Example of a webpage using Bootstrap framework rendered in Mozilla Firefox

Creating a simple fluid layout grid

    <div class="row">
       <div class="col-md-4">Text for column 1</div>
       <div class="col-md-4">Text for column 2</div>
       <div class="col-md-4">Text for column 3</div>

This will create three columns of equal width. This is a fluid layout: If the columns are too wide to fit on the screen, they will be stacked automatically.

See more resources:

Creating a Responsive Menu in WordPress for Mobile Devices
Flat UI Pro – Bootstrap Design Framework
Bootstrap grid examples
jQuery ScrollSpy

Build My Site

Elements of an Android App

Creating an app for Android doesn’t require a full-blown integrated development environment. There are several simple, easy-to-learn and easy-to-use tools that make programming Android apps a breeze. Michael Lehman introduces MIT App Inventor 2, Basic4android, and a few other entry-level development environments to build your own app. He’ll show how to test apps on an Android emulator or directly on your phone or tablet, and demonstrate tools for building hybrid apps that run on Android, Windows Phone, and iOS devices, as well as straight on the web. Start building your first app with these simple tools today. See more at: Simple Android Development Tools.

Topics include:

  • Understanding the elements of an Android app, such as controls, sensors, effectors, and storage
  • Exploring MIT App Inventor 2
  • Getting started with Basic4android
  • Building simple apps
  • Testing apps on Android emulators and devices
  • Sharing apps
  • Creating hybrid apps with Appy Pie, Make Me Droid, and AppMakr

App Inventor for Android

Google App Inventor
App Inventor for Android is an open-source web application originally provided by Google, and now maintained by the Massachusetts Institute of Technology (MIT).

It allows newcomers to computer programming to create software applications for the Android operating system (OS). It uses a graphical interface, very similar to Scratch and the StarLogo TNG user interface, which allows users to drag-and-drop visual objects to create an application that can run on Android devices. In creating App Inventor, Google drew upon significant prior research in educational computing, as well as work done within Google on online development environments.

App Inventor and the projects on which it is based are informed by constructionist learning theories, which emphasizes that programming can be a vehicle for engaging powerful ideas through active learning. As such, it is part of an ongoing movement in computers and education that began with the work of Seymour Papert and the MIT Logo Group in the 1960s and has also manifested itself with Mitchel Resnick’s work on Lego Mindstorms and StarLogo.

App Inventor includes:

  • A designer, in which a program’s components are specified. This includes visible components, such as buttons and images, which are placed on a simulated screen, and non-visible components, such as sensors and web connections.
  • A blocks editor, in which the program’s logic is created.
  • A compiler based on the Kawa language framework and Kawa’s dialect of the Scheme programming language, developed by Per Bothner and distributed as part of the GNU operating system by the Free Software Foundation.
  • An app for real-time debugging on a connected Android device.

On December 6, 2013 (the start of the Hour of Code), MIT released App Inventor 2, renaming the original version “App Inventor Classic” Major differences are:

  • The blocks editor in the original version ran in a separate Java process, using the Open Blocks Java library for creating visual blocks programming languages.
    Open Blocks is distributed by the Massachusetts Institute of Technology’s Scheller Teacher Education Program (STEP) and is derived from master’s thesis research by Ricarose Roque. Professor Eric Klopfer and Daniel Wendel of the Scheller Program supported the distribution of Open Blocks under an MIT License. Open Blocks visual programming is closely related to StarLogo TNG, a project of STEP, and Scratch, a project of MIT Media Laboratory’s Lifelong Kindergarten Group. App Inventor 2 replaced Open Blocks with Blockly, a blocks editor that runs within the browser.
  • The | MIT AI2 Companion app enables real-time debugging on connected devices via Wi-Fi, not just USB.

As of May 2014, there were 87 thousand weekly active users of the service and 1.9 million registered users in 195 countries for a total of 4.7 million apps built.

Build My Site

Packaging an Android app

In this course, author David Gassner shows you how to prepare, package, and publish your Android app on Google Play, and provides a brief overview of the alternatives offered by Amazon and Barnes & Noble. Watch the online video course: Distributing Android Apps

Topics include:

  • Packaging an Android app
  • Distributing through Google vs. Amazon vs. Barnes & Noble
  • Exporting the APK file
  • Testing the app
  • Shrinking and protecting an app with ProGuard
  • Creating and uploading screenshots to Google Play
  • Adding in-app products
  • Tracking app usage and revenue

Android Apps

Android 4.4.2 home screen
Android has a growing selection of third party applications, which can be acquired by users either through an app store such as Google Play or the Amazon Appstore, or by downloading and installing the application’s APK file from a third-party site. The Play Store application allows users to browse, download and update apps published by Google and third-party developers, and is pre-installed on devices that comply with Google’s compatibility requirements. The app filters the list of available applications to those that are compatible with the user’s device, and developers may restrict their applications to particular carriers or countries for business reasons. Purchases of unwanted applications can be refunded within 15 minutes of the time of download, and some carriers offer direct carrier billing for Google Play application purchases, where the cost of the application is added to the user’s monthly bill.

As of July 2013, there are more than one million applications available for Android in the Play Store. As of May 2013, 48 billion apps have been installed from the Google Play store.

Applications (“apps”), that extend the functionality of devices, are developed primarily in the Java programming language language using the Android software development kit (SDK). The SDK includes a comprehensive set of development tools, including a debugger, software libraries, a handset emulator based on QEMU, documentation, sample code, and tutorials. The officially supported integrated development environment (IDE) is Eclipse using the Android Development Tools (ADT) plugin. Other development tools are available, including a Native Development Kit for applications or extensions in C or C++, Google App Inventor, a visual environment for novice programmers, and various cross platform mobile web applications frameworks.

It was announced in January 2014 that Chrome HTML5 web applications should become available, using a compatibility layer from the open source Apache Cordova framework to allow such applications to be wrapped in a native application shell, enabling their distribution over Google Play.

In order to work around limitations on reaching Google services due to Internet censorship in the People’s Republic of China, Android devices sold in the PRC are generally customized to use state approved services instead.

Learn to Build a Simple Android App Interactive Video Learning Path

from: Treehouse

Build My Site