ECEP VIRTUAL CAMPUS

Programming Mobile Applications for Android Handheld Systems

Introduction to the design and implementation of applications for handheld systems, such as smartphones and tablets, running the Android Platform.

About the Course

Handheld systems, such as smartphones and tablets are now the most common way for people to access and interact with computing services. The demand for application development skills is therefore growing at a breathtaking pace. These skills, however, are multi-­‐ faceted, requiring students to master computer science and engineering principles, to learn the details of specific mobile application platforms, and to design artistic and engaging user interfaces that respond to how, where and why handheld applications are used.

This course will cover the fundamental programming principles, software architecture and user experience considerations underlying handheld software applications and their development environments. To bring these concepts alive, the course will involve in-­‐depth, hands-­‐on examples, implemented in the Android Platform, the fastest growing segment of the handheld system user base. Students will apply these teachings, also using the Android Platform, in laboratory projects and in a large-­‐scale semester project. 

Note: This course is part of a Coursera Specialization

This course and two others, led respectively by Drs. Douglas Schmidt and Jules White of Vanderbilt University, have been designed to complement each other. Click here to find out more about the Mobile Cloud Computing with Android (MoCCA) Specialization. Therefore, some of the programming assignments and the course project for these courses will be coordinated.

This course focuses on handheld systems and the design of user-facing applications, and will be taught first. The first Vanderbilt University course, Pattern-Oriented Software Architectures: Programming Mobile Services for Android Handheld Systems will focus on systems programming topics, such as middleware services and background processing. The second Vanderbilt University course, Programming Cloud Services for Android Handheld Systems will focus on connecting Android mobile devices to cloud computing and data storage resources, essentially turning a device into an extension of powerful cloud-based services on popular cloud computing platforms, such as Google App Engine and Amazon EC2.

Nevertheless, each of these courses stands alone. Students are not required to take all of them. Those who do, however, will gain a much more detailed, end-to-end understanding of handheld systems and their applications.

Course Syllabus

Schedule

Week #1:

Objective: In this lesson, I discuss the Android Platform and the Android Development Environment. By the end of this lesson you should understand the components comprising the Android Platform and be able to use various tools found in the Android Development Environment

•  Lecture #1 – The Android Platform

•  Lecture #2 – The Android Development Environment

•  Lab #1: Setup: Students identify required software & install it on their personal computers.  Students perform several tasks to familiarize themselves with the Android Platform and Development Environment. 

Week #2:

Objective: In this lesson, I explain the basic components from which all Android applications are created. I also present the Activity class - one of the main class responsible for displaying an application's user interface. By the end of this lesson, you should recognize the four fundamental components of Android applications, be able to create a simple Android application and understand the lifecycle of the Activity class.

•  Lecture #3 – Application Fundamentals

•  Lecture #4 – The Activity Class

•  Lab #2 – The Activity Lifecycle & Reconfiguration: Students build applications that trace the lifecycle callback methods issued by the Android platform and that demonstrate Android's behavior when the device configuration changes (e.g., when the device moves from portrait to landscape mode and back).

Week #3:

Objective: In this lesson, I explain the Intent class and Permissions. I also present the Fragment class - another key class responsible for displaying an application's user interface. By the end of this lesson, you should be able to create applications comprising more than one Activity, understand how to define and enforce permissions and be able to design applications that run on multiple, differently-sized devices.

•  Lecture #5 – The Intent Class

•  Lecture #6 – Permissions

•  Lecture #7 – The Fragment Class

•  Lab #3a - Intents & Permissions:  Students build applications that require starting multiple Activities via both standard and custom Intents.
•  Lab #3b - Permissions:  Students build applications that require standard and custom permissions.
•  Lab #3c – Multi-pane and single-pane User Interfaces: Students build an application that uses a single code base, but creates different user interfaces depending on a device's screen size. 

Week #4: 

Objective: In this lesson, I summarize and demonstrate the many class Android provides for creating user interfaces. By the end of this lesson, you should be able to define and deploy applications with sophisticated user interfaces.

• Lectures #8 – User Interface Classes - Part I

• Lectures #9 – User Interface Classes - Part II

• Lab #4 – ToDoManager:  Students build a ToDo list manager using the user interface elements discussed in lecture. The application allows users to create new ToDo Items and to display them in a ListView. 

• Mini-project - Modern Art User Interfaces: Students will build a complete app from scratch. Collaborators from the Musuem of Modern Art will help student draw some inspiration from the work of several Modern Art masters.

Week #5:

Objective: In this lesson, I dive deeper in Android, focusing on advanced some of the advanced capabilities it provides. I discuss using User Notifications to interact with the user, listening for and responding to events using the BroadcastReceiver class, and handling concurrency with Threads, AsyncTask & Handlers. There are also two optional lectures dealing with using Alarms to run code at pre-scheduled times and with understanding how to access data over the network. By the end of this lesson, you should understand how these key technologies are used to support more advanced Android applications.

• Lecture #10 – User Notifications

• Lecture #11 – The BroadcastReceiver Class

• Lecture #12 – Threads, AsyncTask & Handlers

• Lecture #13 - Alarms

• Lecture #14 - Networking

• Lab #5 – Tweet app: Students build an app that downloads and displays Tweet data. The app uses an AsyncTask for downloading data over the network. The app will also user BroadcastReceivers and User Notifications to apprise the user of the apps behavior and state.

Week #6:

Objective: In this lesson, I present a number of technologies related to presenting and interacting with dynamic content. This includes graphics and animation, handling touch input from the user, and recording and playing multimedia. By the end of this lesson, you should be able to animate your applications, create apps that respond to both standard and custom gestures, and display and use multimedia content.

• Lecture #15 – Graphics & Animation I

• Lecture #16 – Graphics & Animation II

• Lecture #17 – Multi-touch & Gestures

• Lecture #18 – MultiMedia

• Lab #6 - Bubble Popper: Students write an application to display and animate bubbles (graphics that look like bubbles) on the device's screen. When users touch the screen where a bubble is displayed, the bubble pops. The app will also accept gesture input, allowing the user to change the direction and speed of the bubble, using a fling gesture.

Week #7:

Objective: In this lesson, I go over the many sensors that now come standard on most mobile devices. I also provide a focused discussion of using sensors to capture location information and using maps to display that information. By the end of this lesson, you should be able to create context aware applications whose behavior changes based on environmental conditions.

• Lecture #19 – Sensors

• Lecture #20 – Location & Maps

• Lab #7 - Place Badge Collector: Students build an application that uses location information to collect Badges for the places they visit.

Week #8:

Objective: In this lesson, I wrap up with a discussion of some behind the scenes Android capabilities. I discuss how to manage structured data, how to share that data across applications using the ContentProvider class, and how to run operations in the background and across processes using the Service class. By the end of this lesson, you should be able to design complex applications that leverage complex structured data sets and that perform processing in the background.

• Lecture #21 – DataManagement

• Lecture #22 – The ContentProvider Class

• Lecture #23 – The Service Class

• Lab #8 - Place Badge Collector Content Provider: Students build a ContentProvider to store the Place Badges they collect with the app from Weekk 7 application that uses location information to collect Badges for the places they visit.

Mini-project - DailySelfie: Students will build a complete app from scratch. This app will remind users to take a picture of themselves once a day. The app will collect and display the resulting set of photos.

Recommended Background


This course is directed to Sophomore- or Junior-level undergraduate students. Students should already know how to program in Java, but are not expected to have studied mobile application development. 

If you don't already know Java, but have strong familiarity with other programming languages, you can improve your Java knowledge, by taking one of the many Java tutorials and online courses available on the web.

As discussed above, this course assumes previous programming knowledge. It also assumes that you are willing to search for, read and learn from Android's developer documentation. Based on our previous experience, students who don't meet these criteria often end up being quite frustrated with the course.

In short, this course is not designed for truly novice programmers. If your background is not appropriate for this class, consider first taking a less programming heavy introduction to Android such as, "Creative, Serious and Playful Science of Android Apps", by Lawrence Angrave of the University of Illinois and Urbana-Champaign.

Suggested Readings

There is no textbook for this course, but I strongly encourage students to explore the wide range of freely-available Android-related resources.
  • Keep up with changes and improvements in the Android ecosystem by reading the Android Developer's Blog.
  • Watch tutorials and other presentations from the Google I/O conference.

Course Format

Each lesson will consist of video presentations, logically divided roughly into 5-10 minute sections. Throughout the lecture video there are ungraded "in-video" questions to help ensure that students are understanding the material.  Each week there is also a short quiz containing questions/tasks to help ensure that the students have understood that week's lectures. 

The in-video questions are related to the current video section, and provide supplementary information, “Food For Thought” discussion, and "FLASHBACK" questions, which challenge the students to think about something we have discussed in a previous lesson.

Each week's videos will be accompanied by a lab exercise consisting of an assignment write-up, partially completed source code, and executable test cases. The students will run the test cases on their own computers to determine whether they've successfully completed the lab. For some labs, we will also require students to examine and grade the submissions of other students.

Each lesson covers multiple Android source code examples. I strongly encourage students to download all the examples and to consult them both while watching the lecture and afterwards. The source code is publicly available on github:

https://github.com/aporter/coursera-android

The course will also have a complex final project. 

FAQ

Some Frequently Asked Questions. 
  • What are the course objectives?

    Upon completing this course, students should be able to:

    • Understand the Android platform's organization, patterns and programming mechanisms and be able to  use them effectively to develop their own Android applications.
    • Use development tools, such as those found in the Android Developer's Toolkit to efficiently create, understand, debug and optimize Android applications.

    • Understand the key forces and constraints acting on handheld devices and know how to accommodate these when designing and building their own Android applications.

    • Know where to find additional sources of information to understand and solve Android-related problems.
  • Can students take this course if they have no prior experience with Android programming or programming with Java? 
  • This course assumes that students are comfortable programming in Java and have some experience programming Android apps. If you don't have any significant Java programming background, please look on the Internet for one of the many Java-related tutorials that are freely-available.

  • When I try to watch the videos before the class start, I get an error message.
  • You can preview some of the videos by pressing the "Preview Lectures" Button at the top of the course webpage

  • Is the course broadcast live? I live on the other side of the world from you! No. Course lectures are videotaped. Students watch the lectures and do programming assignments and quizzes when it's convenient for them.
  • What resources will I need for this class?

    For this course, you'll need is an Internet connection, a computer on which to run free Android developer tools, and the time to read, write, and discuss.

  • What is the coolest thing I'll learn if I take this class?
  • How to write the software applications that you and half the world are running on your handheld devices.

  • What computer languages do I need to know?
  • Experience with Java should be enough. As mentioned in the Recommended Background Section, those who don't know Java, but have strong familiarity with other languages may want to take a Java tutorial prior to starting this course.

  • Can students use programming language, other than Java, for the course?
  • Not really. The main programming language for Android is Java.

  • What should I be reading to prepare for class?
  • There is no course textbook. If you want to get started early, dive into the Android Developer's Website

  • Do I need to buy an Android device? 

    No. All the graded exercises will be done using the Android Emulator. 

  • What is a "trans-institution sequence of MOOCs?" 

    This MOOC course and another course tentatively called Pattern-Oriented Software Architectures for Concurrent and Networked Mobile Devices and Clouds, taught by Professors Doug Schmidt and Jules White of Vanderbilt University have been designed to complement each other. In particular, some of the programming assignments and the course project for both courses will be coordinated. The focus of Vanderbilt MOOCs will be systems programming topics, such as server-side Android concurrency, background processing, networking, and computing cloud integration, and will be taught starting in late March 2014. Additional information on our trans-institutional MOOC sequence is available  here and  here

  • Is it necessary to take all the courses in the sequence? 

    No. If you just want to take some of the courses in this sequence--or take them all in different order--you're certainly welcome to do so, and you'll still learn a lot. However, if you take all the courses in this sequence in the order presented you'll gain a deeper, end-to-end understanding of handheld systems, their applications and services, as well as their integration into the cloud.

  • When will the course material be made available each week? 

    All the course material (e.g., video lectures, quizzes, short essays, programming assignments, etc.), for each week will be made available at 12:00am eastern time (5am UTC/GMT). each Friday of the course.

  • How does this MOOC compare/contrast with courses at the University of Maryland? This MOOC is heavily based on courses I teach at UMD, called CMSC436, Programming Handheld Systems. The course lecture material is similar, but the quizzes, programming assignments, and level of feedback for the UMD courses are more challenging, given that we have about twice the amount of time to work on it. Also, as the UMD course has many fewer students, there's significantly more personalized guidance from the professor and TAs that can't (yet) be replicated via a MOOC. This is one reason why it's important for students to take on some of the  role of the Instructor. When we all work together, we all benefit.
  • What is the most effective way to learn material covered in the course? 

    I recommend watching the videos multiple times, looking for different levels of meaning in the diagrams and the examples. Likewise, I recommend reading outside sources of information. Naturally, participating in the online discussion forums (and ideally, a meetup group if one is available in your area) will help make the course material more engaging.

  • Will you use Eclipse or Android Studio in this course? 
  • All of my videos use Eclipse as Android Studio is still in a pre-release state. If you're using a non-Eclipse development environment, such as AndroidStudio, you may need to enlist the help of other students on the online discussion forum.

  • Which web browsers are recommended? 

    Coursera recommends using the Chrome and Firefox browsers. There's also a mobile app for Coursera MOOC, as well.

  • Where can students download the slides that are presented in the videos? 

    PDF versions of the slides will be available online as the videos are released. 

Starts August 18, 2015

Course at a Glance

10 weeks of study 2-4 hours/week English English & Vietnamese subtitles