Understanding Android Application Basics

Start learning the skills necessary to become a successful Android developer by developing your understanding of Android application development and the creation of interactive user experiences with Android Activities.
Course info
Rating
(112)
Level
Beginner
Updated
Mar 31, 2017
Duration
3h 51m
Table of contents
Building a Simple App
Designing and Planning Our App
Understanding Activities and Activity Layout Interaction
Working with Activities
Taking a Deeper Look at Activity Interaction
Understanding Activity Lifecycle
Description
Course info
Rating
(112)
Level
Beginner
Updated
Mar 31, 2017
Duration
3h 51m
Description

The key to becoming a successful Android app developer is getting the basics right. Android is a component-based platform that has a different programming model than many other platforms. Understanding this component model, especially the familiar UI components known as Activities, is essential to success. In this course, Understanding Android Application Basics, you'll get a better understanding of the Android application basics. First, you'll start by deploying a simple Android application to become familiar with the environment. Next, you'll walk through the process of designing the user experience for a more involved application. Finally, using the Android Studio designer, you'll layout an interactive activity and connect it to Java code. Throughout the course you'll continue enhancing the app to become a multi-activity user experience that provides interactive editing features and proper Activity lifecycle management.

About the author
About the author

Jim Wilson is president of JW Hedgehog, Inc., a consulting firm specializing in solutions for the Android, iOS, and Microsoft platforms. Jim has over 30 years of software engineering experience, with the past 15 years heavily focused on creating mobile device and location-based solutions.

More from the author
More courses by Jim Wilson
Section Introduction Transcripts
Section Introduction Transcripts

Designing and Planning Our App
Welcome to the Designing and Planning Our App module of the Pluralsight course, Understanding Android App Basics. My name is Jim Wilson. in this module, we introduce the app we'll be building throughout the remainder of this course series. So let's first take a quick look at the high-level view of the app that we'll build throughout this course series, and also some of the long-term plans we have for that app that will really leverage the power and capabilities of Android. We'll then dig into and design the specific features we'll be implementing in this particular course. So we'll first take a look at the rough design of the work we're going to do throughout this course on our app, and then we'll take a look at the more polished design of the work that we're going to do on that app throughout this course. And then finally, we'll create the Android Studio project we'll be using to work on our application throughout this course series. Alright, so let's jump into our next clip and start looking at the app we'll be building.

Understanding Activities and Activity Layout Interaction
Welcome to the Understanding Activities and Activity Layout Interaction module of the Pluralsight course, Understanding Android App Basics. My name is Jim Wilson. In this module, we're going to start out by answering the question, just what is an Activity? From there, we'll look at what's used to construct an Activity user interface. We'll then take a close look at the classes called Layout classes that we use to actually organize the layout of our Activity user interface. We'll then dig into one of the newer layout classes called ConstraintLayout. From there, we'll take a close look at the relationship between an Activity and its Layout, and we'll finish up with populating a Spinner. And that's interesting for us in this module, because Spinners are views that actually leverage layouts to control their appearance.

Working with Activities
Welcome to the Working with Activities module of the Pluralsight course, Understanding Android App Basics. My name is Jim Wilson. We'll start out looking at how activities interact. We'll then dig into the role of Intents and describing Android operations. Now an important part of describing operations with Intents are what are called Extras, and we'll dig into the special challenge that reference types play when passing them as Extras. We'll then see how to implement an interface called Parcelable, a very important part of passing reference types as Extras. As we discuss each of these topics, we'll also be adding some great features to our app. We'll add an activity that displays our list of notes, and we'll make that activity our app startup activity, we'll add handling to display a note in the NoteActivity when the user selects a note from the list, and then we'll finish up by hooking up our new note behavior. Okay, so let's get started.

Taking a Deeper Look at Activity Interaction
Welcome to the Taking a Deeper Look at Activity Interaction module of the Pluralsight course, Understanding Android App Basics. My name is Jim Wilson. In this module, we're going to look at how we can create more sophisticated applications by leveraging the interaction capabilities of activities. And to do that, we're first going to look at the application activity relationship, something called implicit intents that will allow us to actually launch activities based on characteristics, how do we use activities that return results, and how activities are organized in something called tasks. Okay, so let's get started.

Understanding Activity Lifecycle
Welcome to the Understanding Activity Lifecycle module of the Pluralsight course, Understanding Android App Basics. My name is Jim Wilson. In this module, we're going to start out looking at the Activity lifecycle, which are the phases of existence that Activities go through from creation, to their trip to being in the foreground, and then eventually being destroyed. We'll then take a look at the methods that we use to appropriately handle each of these lifecycle phases. And then finally we'll go to Activity State Management. As we'll see, Activities can often be destroyed and recreated, and we have to manage Activity instance state throughout that process. Alright, so let's get started.