Nanodegree key: nd801
Version: 7.0.0
Locale: en-us
For intermediate programmers pursuing Android mastery, this program teaches the tools, principles, and patterns that underlie all Android development.
Content
Part 01 : Welcome to Your Nanodegree
Welcome to your Android Developer Nanodegree! Here's an overview of the program, along with some helpful resources to get you started.
-
Module 01: Welcome to Your Nanodegree
-
Lesson 01: Welcome to Your Nanodegree
Welcome to your Android Developer Nanodegree! Here's an overview of the program, along with some helpful resources to get you started.
-
Part 02 : Developing Android Apps
-
Module 01: Developing Android Apps, Part 1
-
Lesson 01: Create Project Sunshine
In the first lesson of Developing Android Apps, you'll learn how to create and run your first simple Android app. In doing so, you'll explore how to create simple layouts for Android, how Android runs on the phone and the IDE Android Studio.
- Concept 01: Introduction
- Concept 02: Are you ready?
- Concept 03: Introducing Project Sunshine
- Concept 04: A Brief Intro to Android Studio
- Concept 05: Coding, GitHub and Flow
- Concept 06: Quiz: Coding, GitHub and Flow
- Concept 07: Creating our First Project
- Concept 08: Android Min and Target Versions
- Concept 09: Setting Min and Target
- Concept 10: Running Your Code
- Concept 11: Android Software Stack
- Concept 12: Activities, Packages, and Layouts
- Concept 13: Android Basics
- Concept 14: Android Layouts Primer
- Concept 15: Exercise: Framing Favorite Toys
- Concept 16: Exercise: Toying with FavoriteToys
- Concept 17: Exercise: See More FavoriteToys
- Concept 18: Visual Layout Editor
- Concept 19: Handling Different Screen
- Concept 20: Responsive Design
- Concept 21: Layout Managers
- Concept 22: Exercise: Update Sunshine Layout
- Concept 23: Solution: Update Sunshine Layout
- Concept 24: Exercise: Add Scrolling Weather
- Concept 25: Solution: Add Scrolling Weather
- Concept 26: Recap
-
Lesson 02: Connect to the Internet
In this lesson you'll harness the power of the Internet by connecting Sunshine to the cloud! You'll learn how to make requests to an API and visualize what's returned in your Android app, with an emphasis on performance. You'll also explore modifying the Action Bar of your app to add menu items.
- Concept 01: Introduction
- Concept 02: Logging
- Concept 03: Internet Toy App Intro
- Concept 04: Exercise: Create a Layout
- Concept 05: Resources
- Concept 06: On Menus
- Concept 07: Exercise: Add a Menu
- Concept 08: Exercise: Build our URL
- Concept 09: Fetching an HTTP Request
- Concept 10: Permissions
- Concept 11: Quiz: Permissions
- Concept 12: Exercise: Connect to the Internet
- Concept 13: Thread Basics
- Concept 14: AsyncTask
- Concept 15: Quiz: AsyncTask
- Concept 16: Exercise: Create an AsyncTask
- Concept 17: Exercise: Missing Permissions
- Concept 18: Exercise: Add Polish
- Concept 19: JSON Format
- Concept 20: Quiz: JSON by Hand
- Concept 21: Quiz: Parse JSON
- Concept 22: Exercise: Networking
- Concept 23: Exercise: Menus
- Concept 24: Exercise: Add Loading Polish
- Concept 25: Refresh Bad!!!
- Concept 26: Recap
-
-
Module 02: Project: Sandwich Club
-
Lesson 01: Sandwich Club
In this project, you will complete an app by building a layout and populating its fields from data received as JSON.
-
-
Module 03: Developing Android Apps, Part 2
-
Lesson 01: RecyclerView
Many apps need the ability to display large lists of data. You'll learn how to do this efficiently with Adapters and the RecyclerView class. By the end of this lesson, you'll be efficiently showing off many days worth of weather data.
- Concept 01: Introduction
- Concept 02: Why RecyclerView?
- Concept 03: How RecyclerView Works
- Concept 04: Using RecyclerView
- Concept 05: Why ViewHolders?
- Concept 06: findViewByld() Calls
- Concept 07: Visualizing ViewHolders
- Concept 08: Creating RecyclerView Layout
- Concept 09: Exercise: Create RecyclerView
- Concept 10: Items and ViewHolders
- Concept 11: Exercise: Items and ViewHolders
- Concept 12: RecyclerView and Adapters
- Concept 13: Adapters and RecyclerView
- Concept 14: Creating an Adapter
- Concept 15: Exercise: Create an Adapter
- Concept 16: RecyclerView Layout Manager
- Concept 17: Wiring Up RecyclerView
- Concept 18: Exercise: Wiring Up RecyclerView
- Concept 19: Visualizing Recycling
- Concept 20: Responding to Item Clicks
- Concept 21: Exercise: Click Handling
- Concept 22: Exercise: Create a RecyclerView
- Concept 23: Exercise: Click Handling
- Concept 24: Recap
-
Lesson 02: Intents
This lesson is all about making multi-screen apps using Intents. You'll learn how to use explicit intents to open up different app screens. You'll also learn about implicit intents, which are a powerful part of the Android framework that allows you to send and receive data from other apps, such as Google maps, Chrome and a host of social media apps.
- Concept 01: Introduction
- Concept 02: Sunshine App UX Mocks
- Concept 03: Intents Framework
- Concept 04: Explicit Intent Toy App
- Concept 05: Creating an Activity
- Concept 06: Exercise: Create an Activity
- Concept 07: Creating an Intent
- Concept 08: Exercise: Start an Activity
- Concept 09: Passing Data Between Activities
- Concept 10: Exercise: Pass Data
- Concept 11: What are Implicit Intents?
- Concept 12: Creating Implicit Intents
- Concept 13: Exercise: Open a Web Page
- Concept 14: Understanding URIs
- Concept 15: Identify Parts of URIs
- Concept 16: Creating a Map Intent
- Concept 17: Exercise: Show a Map
- Concept 18: Sharing is Caring!
- Concept 19: Media Types
- Concept 20: Implementing a Share Intent
- Concept 21: Exercise: Create a Share Intent
- Concept 22: Explicit vs Implicit Intents
- Concept 23: Exercise: Add a New Activity
- Concept 24: Exercise: Send Data
- Concept 25: Exercise: Add Sharing
- Concept 26: Recap
-
-
Module 04: Project: Popular Movies, Stage 1
-
Lesson 01: Popular Movies, Stage 1
Build an app to help users discover popular and recent movies. You will build a clean UI, sync to a server, and present information to the user.
-
-
Module 05: Developing Android Apps, Part 3
-
Lesson 01: Lifecycle
One of the critical parts of Android any good developer needs to understand is the Android Lifecycle. In this lesson you'll learn about how activities are created and destroyed. You'll also learn how to properly persist data between rotations of the device.
- Concept 01: Introduction
- Concept 02: Why We Need an Activity Lifecycle
- Concept 03: Android Activity Lifecycle
- Concept 04: Reto on the Android Activity Lifecycle
- Concept 05: Exercise: Lifecycle Events
- Concept 06: Why does this Happen?
- Concept 07: Save and Restore Instance State
- Concept 08: Exercise: Persisting Data
- Concept 09: Exercise: Fix the Lifecycle Display
- Concept 10: App Termination
- Concept 11: Preparing for Termination
- Concept 12: Persisting Data With an Old Friend
- Concept 13: Exercise: Persisting Data Part Two
- Concept 14: AsyncTask and Loaders
- Concept 15: Quiz: AsyncTaskLoader Advantages
- Concept 16: Leveraging Loaders
- Concept 17: Exercise: Add an AsyncTaskLoader
- Concept 18: Caching with Loaders
- Concept 19: Exercise: Caching with Loaders
- Concept 20: Exercise: AsyncTaskLoader in Sunshine
- Concept 21: Conclusion
-
Lesson 02: Preferences
In this lesson, you'll learn how to give users a customized experience by creating Preference screens. You'll practice first adding preferences first in a sample music visualizer app. After that, you'll finish the lesson by adding tempurate and location settings to Sunshine.
- Concept 01: Introduction
- Concept 02: Introducing the Visualizer
- Concept 03: Visualizer Code
- Concept 04: Download the Code
- Concept 05: Data Persistence
- Concept 06: Persistent Storage Options
- Concept 07: Preference Fragments
- Concept 08: Setting up the Settings Activity
- Concept 09: Exercise: Setup Settings
- Concept 10: Making a PreferenceFragment
- Concept 11: Exercise: Make a Preference Fragment
- Concept 12: Reading From SharedPreferences
- Concept 13: Exercise: Reading from SharedPreferences
- Concept 14: Use Resources!
- Concept 15: Exercise: Use Resources
- Concept 16: Why Aren’t The Preferences Changing?
- Concept 17: Preference Change Listener
- Concept 18: Exercise: Preference Change Listener
- Concept 19: Add Two More Checkboxes
- Concept 20: Exercise: Add Two More Checkboxes
- Concept 21: List Preference
- Concept 22: Exercise: List Preference
- Concept 23: Preference Summary
- Concept 24: Exercise: Preference Summary
- Concept 25: Edit Text Preference
- Concept 26: Exercise: Edit Text Preference
- Concept 27: Edit Size Crashes
- Concept 28: Edit Text Preference Constraints
- Concept 29: Exercise: Edit Text Preference Constraints
- Concept 30: Preferences in Sunshine
- Concept 31: Should it be a Setting
- Concept 32: Exercise: Create the SettingsActivity in Sunshine
- Concept 33: Solution: Create the SettingsActivity in Sunshine
- Concept 34: Exercise: Create the PreferenceFragment in Sunshine
- Concept 35: Exercise: Update the MainActivity
- Concept 36: Conclusion
-
Lesson 03: Storing Data in SQLite
In this lesson you'll start your exploration into data persistence on Android by implementing a SQLite database. In doing so, you'll create a restaurant queuing app and make the first steps towards adding persistence to Sunshine.
- Concept 01: Introduction
- Concept 02: Why SQLite?
- Concept 03: SQL Query
- Concept 04: Waitlist ToyApp
- Concept 05: Creating the Contract
- Concept 06: Running Unit Tests
- Concept 07: Exercise: Create the Contract
- Concept 08: Creating the database
- Concept 09: Exercise: Create The Database
- Concept 10: Querying All Guests
- Concept 11: Exercise: Query All Guests
- Concept 12: Updating the Adapter
- Concept 13: Exercise: Update The Adapter
- Concept 14: Adding Guests
- Concept 15: Swap cursor
- Concept 16: Exercise: Add Guests
- Concept 17: Removing Guests
- Concept 18: Exercise: Remove Guests
- Concept 19: Exercise: Sunshine Database
- Concept 20: Exercise: Invalid Inserts in
- Concept 21: Exercise: Resolve Conflicts
-
Lesson 04: Content Providers
Content Providers are a core Android Framework component that help you provide and manage access to your app's data. In this lesson, you'll learn how to leverage a content provider to get data from other apps on the phone by making a Flashcard app.
- Concept 01: Introduction
- Concept 02: Content Providers
- Concept 03: Content Provider Advantages
- Concept 04: DroidTermsExample
- Concept 05: Exercise: Setup QuizExample
- Concept 06: Content Provider Permissions
- Concept 07: Exercise: Add the Permission
- Concept 08: The Content Resolver
- Concept 09: Four Basic Operations
- Concept 10: Uniform Resource Identifier
- Concept 11: Quiz: TVTime
- Concept 12: Solution: TVTime
- Concept 13: Actor Query
- Concept 14: Solution: Actor Query
- Concept 15: Quiz: Calendar Provider
- Concept 16: Solution: Calendar Provider
- Concept 17: Calling the ContentProvider
- Concept 18: Exercise: Make an AsyncTask
- Concept 19: Structure of the Data
- Concept 20: Working with Cursors Review
- Concept 21: Exercise: Use the Cursor
- Concept 22: Solution: Use the Cursor
- Concept 23: Conclusion
-
Lesson 05: Building a Content Provider
In this lesson you'll get to make your own Content Provider! You'll first create a content provider for a To-do list app, and then you'll create a Content Provider for Sunshine's weather data.
- Concept 01: Introduction
- Concept 02: ToDo List Code
- Concept 03: Exercise: Data Design
- Concept 04: Steps to Create a Provider
- Concept 05: Create TaskContentProvider
- Concept 06: Exercise: Create and Register a ContentProvider
- Concept 07: Define the URI Structure
- Concept 08: Wildcard Characters
- Concept 09: Quiz: Design Task URIs
- Concept 10: Exercise: Change the Contract
- Concept 11: Build the URIMatcher
- Concept 12: Exercise: Which Match
- Concept 13: Solution: Which Match
- Concept 14: Exercise: Add a URIMatcher
- Concept 15: A Small Note on Testing
- Concept 16: Resolver to Database Flow
- Concept 17: Overview of Provider Functions
- Concept 18: Quiz: Determine the CRUD Method
- Concept 19: Insert
- Concept 20: Hook it up to the UI
- Concept 21: Exercise: Implement Insert
- Concept 22: Query
- Concept 23: Display the Tasks
- Concept 24: Exercise: Implement Query
- Concept 25: Query for One Item
- Concept 26: Query for One Item Part Two
- Concept 27: Exercise: Selection and SelectionArgs
- Concept 28: Exercise: Implement Delete
- Concept 29: Exercise: Swipe to Delete
- Concept 30: Update
- Concept 31: getType
- Concept 32: Working ToDo List App!
- Concept 33: Applying This to Sunshine
- Concept 34: Testing
- Concept 35: Exercise: Sunshine Content Provider and Query
- Concept 36: Solution: Sunshine Content Provider and Query
- Concept 37: Exercise: bulkInsert
- Concept 38: Solution: bulkInsert
- Concept 39: Exercise: Add Delete Functionality
- Concept 40: Solution: Add Delete Functionality
- Concept 41: Exercise: Using a CursorLoader
- Concept 42: Solution: Using a CursorLoader
- Concept 43: Exercise: More Weather Details
- Concept 44: Solution: More Weather Details
- Concept 45: Outro
-
Lesson 06: Android Architecture Components
In this lesson, learn how Android Architecture Components can solve common challenges to build robust and efficient apps.
- Concept 01: Intro
- Concept 02: ToDo List App
- Concept 03: Intro to Room
- Concept 04: Exercise: Creating an Entity
- Concept 05: Column Name
- Concept 06: Creating a DAO
- Concept 07: Creating the Database
- Concept 08: Type Converters
- Concept 09: Quiz: I hereby promise…
- Concept 10: Exercise: Save Task
- Concept 11: Exercise: Query all Tasks in MainActivity
- Concept 12: Threads and Runnables
- Concept 13: Exercise: Executors
- Concept 14: Exercise: Delete Task
- Concept 15: Queries with Parameters
- Concept 16: Exercise: Update Task
- Concept 17: Re-query for nothing
- Concept 18: LiveData and the Observer Pattern
- Concept 19: Exercise: Adding LiveData
- Concept 20: Exercise: Adding LiveData to AddTaskActivity
- Concept 21: ViewModel
- Concept 22: Exercise: Adding the ViewModel
- Concept 23: Exercise: Adding the ViewModel to AddTaskActivity
- Concept 24: A “Lifecycle” Surprise
- Concept 25: LifecycleOwners and LifecycleObservers
- Concept 26: The Repository
- Concept 27: Recap
-
Lesson 07: Background Tasks
In this lesson you'll learn about how to effectively run jobs in the background, create notifications and periodically schedule long running background processes. To explore these topics you'll create a Hydration Reminder app that tells the user to drink water via a notification, even when the app is not running..
- Concept 01: Introduction
- Concept 02: Running in the Background
- Concept 03: Hydration Reminder
- Concept 04: Services
- Concept 05: Services vs. Loaders
- Concept 06: Quiz: Services vs. Loaders
- Concept 07: Starting Services
- Concept 08: Running Services in the Background
- Concept 09: Intent Services
- Concept 10: Starter Code
- Concept 11: Quiz: Get the Starter Code
- Concept 12: Plan for Adding an IntentService
- Concept 13: Exercise: Add an IntentService
- Concept 14: Notifications
- Concept 15: Notifications in Oreo
- Concept 16: Pending Intents
- Concept 17: Exercise: Notifications
- Concept 18: Notification Actions
- Concept 19: Exercise: Adding Actions to Notifications
- Concept 20: Foreground Services
- Concept 21: Quiz: Application Priority
- Concept 22: Issuing Reminders
- Concept 23: Scheduling Jobs
- Concept 24: Exercise: Adding a JobService
- Concept 25: Exercise: Schedule with FirebaseJobDispatcher
- Concept 26: Broadcast Receivers
- Concept 27: Exercise: Show When Charging
- Concept 28: Exercise: Getting the Current Battery State
- Concept 29: Syncing Sunshine
- Concept 30: Exercise: Synchronizing The Weather
- Concept 31: Exercise: SmarterSyncing
- Concept 32: Exercise: Sunshine FirebaseJobDispatcher
- Concept 33: Exercise: Sunshine Notifications
- Concept 34: Conclusion
-
Lesson 08: Completing the UI
This lesson is all about building a user interface that is well-organized and accessible. You’ll be building a boarding pass app where you’ll learn about different styles of layouts, views and view groups, as well as data binding, and accessibility. At the end of the lesson, you’ll use what you’ve learned to improve the layouts used in Sunshine.
- Concept 01: Introduction
- Concept 02: Views & View Groups
- Concept 03: Quiz: What will this look like?
- Concept 04: Constraint Layout
- Concept 05: Installing the Constraint Layout Library
- Concept 06: Design the Boarding Pass
- Concept 07: Adding Shapes and Images
- Concept 08: Adding Vector Images
- Concept 09: Exercise: Constraint Layout
- Concept 10: Data Binding
- Concept 11: Exercise: Data Binding
- Concept 12: Accessibility & Internationalization
- Concept 13: Accessibility
- Concept 14: Quiz: Accessibility
- Concept 15: Localization
- Concept 16: Responsive Design
- Concept 17: Exercise: Landscape Layout
- Concept 18: Exercise: Sunshine's New Layout
- Concept 19: Solution: Sunshine's New Layout
- Concept 20: Exercise: Sunshine Today's List Item
- Concept 21: Solution: Sunshine Today's List Item
- Concept 22: Exercise: Data Binding in Sunshine
- Concept 23: Solution: Data Binding in Sunshine
-
Lesson 09: Polishing the UI
In this final lesson, you’ll learn how to add visual polish to your apps. You’ll be adding details like colors, fonts, and styles to layouts within an app. You’ll also use principles of design to create apps that look great across different sizes of Android devices. By the end of this lesson, you’ll have added some style and color to Sunshine, and completed this course!
- Concept 01: Introduction
- Concept 02: Android Design Principles
- Concept 03: Toy App
- Concept 04: Visual Mocks and Keylines
- Concept 05: Color Guidelines
- Concept 06: Quiz: Choose a Color Scheme
- Concept 07: Solution: Choose a Color Scheme
- Concept 08: Font Guidelines
- Concept 09: Changing Colors and Fonts
- Concept 10: Exercise: Add Colors and Fonts!
- Concept 11: Styles and Themes
- Concept 12: Style a Mail Layout
- Concept 13: Style Inheritance
- Concept 14: Exercise: Create a New Style
- Concept 15: Designing for Multiple Screens
- Concept 16: Screen Density
- Concept 17: Different Layouts
- Concept 18: Resource Folder Qualifiers
- Concept 19: Smallest Width Qualifier
- Concept 20: Quiz: Choose the Qualifier
- Concept 21: Creating a Tablet Layout
- Concept 22: Exercise: Code a Custom Layout
- Concept 23: Touch Selectors
- Concept 24: Exercise: Code Your Own Selector
- Concept 25: Moving on to Sunshine
- Concept 26: Exercise: Add Colors, Fonts, and Dimensions
- Concept 27: Solution: Add Colors, Fonts, and Dimensions
- Concept 28: Exercise: Create and Apply Styles
- Concept 29: Solution: Create and Apply Styles
- Concept 30: Exercise: Add a Touch Selector
- Concept 31: Solution: Add a Touch Selector
- Concept 32: Exercise: Add Resource Qualifiers
- Concept 33: Solution: Add Resource Qualifiers
- Concept 34: Outro of all Outros
- Concept 35: Next Steps!
-
-
Module 06: Project: Popular Movies, Stage 2
-
Lesson 01: Popular Movies, Stage 2
In this project, you will add to the app you built in Stage 1 by building on the detail view for each movie, allowing users to 'favorite' movies, and adding a tablet layout.
-
Part 03 (Career): Career: Job Search Strategies
Opportunity can come when you least expect it, so when your dream job comes along, you want to be ready.
-
Module 01: Conduct a Job Search
-
Lesson 01: Conduct a Job Search
Learn how to search for jobs effectively through industry research, and targeting your application to a specific role.
-
-
Module 02: Refine Your Resume
-
Lesson 01: Refine Your Entry-Level Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 0-3 years of work experience in any industry.
-
Lesson 02: Refine Your Career Change Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in an unrelated field.
-
Lesson 03: Refine Your Prior Industry Experience Resume
Receive a personalized review of your resume. This resume review is best suited for applicants who have 3+ years of work experience in a related field.
Project Description - Resume Review Project (Prior Industry Experience)
Project Rubric - Resume Review Project (Prior Industry Experience)
- Concept 01: Convey Your Skills Concisely
- Concept 02: Effective Resume Components
- Concept 03: Resume Structure
- Concept 04: Describe Your Work Experiences
- Concept 05: Resume Reflection
- Concept 06: Resume Review
- Concept 07: Resume Review (Prior Industry Experience)
- Concept 08: Resources in Your Career Portal
-
-
Module 03: Write an Effective Cover Letter
-
Lesson 01: Craft Your Cover Letter
Get a personalized review of your cover letter. A successful cover letter will convey your enthusiasm, specific technical qualifications, and communication skills applicable to the position.
-
Part 04 : Advanced Android App Development
Extend what you learned in Developing Android Apps to make your apps more responsive, and create a total user experience with home screen widgets, third-party libraries, and more. You'll also learn to deeply integrate rich media, test user interfaces, and publish to Google Play.
-
Module 01: Advanced Android App Development (NEW)
-
Lesson 01: Welcome to Advanced Android
A quick guide to the course outline, and steps to download any of the code samples to follow along with the lessons.
-
Lesson 02: Fragments
In this lesson, you'll learn all about fragments, an essential building block to create apps with a flexible UI. You'll be getting hands-on experience with creating fragments by building an app called AndroidMe. AndroidMe lets a user customize the hair and clothing of an Android figure. After completing the app, you'll know how to build a beautiful and responsive UI for any app using fragments and the power of modularity and reusability!
- Concept 01: Introduction to Fragments
- Concept 02: Responsive Design
- Concept 03: Why Use Fragments?
- Concept 04: Advantages of Fragments
- Concept 05: Fragment Lifecycle
- Concept 06: Lifecycle Callbacks
- Concept 07: Starting Code
- Concept 08: Create a Fragment
- Concept 09: Steps to Create a Fragment
- Concept 10: Exercise: Create BodyPartFragment
- Concept 11: FragmentManager and Transactions
- Concept 12: More Fragments and Storing Variables
- Concept 13: Exercise: Display Three Fragments
- Concept 14: Practice Replacing a Fragment
- Concept 15: Responding to Clicks
- Concept 16: Exercise: Click Response and Saving State
- Concept 17: Master List Fragment
- Concept 18: Exercise: Create MasterListFragment
- Concept 19: Communicating Between Fragments
- Concept 20: Define an Interface
- Concept 21: Exercise: Interface Communication
- Concept 22: Communicate Between Activities
- Concept 23: Exercise: Communicate Between Activities
- Concept 24: Exercise: Two Pane Layout
- Concept 25: Fragments Outro
-
Lesson 03: Libraries
In this lesson, you'll learn about including external libraries in your application. Libraries will allow you to unlock powerful features with just a few lines of code, as you'll see when you build an app that converts a facial expression in a picture into the closest matching Emoji using the Google Mobile Vision library. By the end of the lesson, you'll know how to find a select a library that suits your needs, as well as the names of a few "must have" Android Libraries.
- Concept 01: Introduction to Libraries
- Concept 02: A Library You've Already Used
- Concept 03: When to Use Libraries
- Concept 04: Quiz: When to Use Libraries
- Concept 05: Find Library Intro
- Concept 06: How to Find a Library
- Concept 07: Choose a Library
- Concept 08: Explore a Library
- Concept 09: Quiz: Exploring a Library
- Concept 10: Exercise: Explore Starter Code
- Concept 11: Explore the Starter Code: Bitmap Utils
- Concept 12: Explore Starter Code Outro
- Concept 13: Exercise: Add Gradle Dependency
- Concept 14: Exercise: Detect Faces Intro
- Concept 15: Detecting Faces
- Concept 16: Detect Faces
- Concept 17: Exercise: Get Probabilities
- Concept 18: Overlay Emoji Intro
- Concept 19: Exercise: Map to Emojis
- Concept 20: Set Probability Thresholds
- Concept 21: Exercise: Overlay Emoji - Step 1
- Concept 22: Overlay Emoji - Step 2
- Concept 23: Overlay Emoji Outro
- Concept 24: Exercise: Must Have Libraries
- Concept 25: Must Have Libraries Outro
- Concept 26: Libraries Outro
-
Lesson 04: Firebase Cloud Messaging
In this lesson, you'll learn how to make a Twitter-like app known as Squawker. You'll learn how to make an app that receives messages from a server in real-time using a service known as Firebase Cloud Messaging. With these skills, you'll be well on your way to making battery efficient apps that can receive updates from the server in milliseconds!
- Concept 01: Introduction to FCM
- Concept 02: Squawker is Cool
- Concept 03: Quiz: Polling vs. Pushing
- Concept 04: Introduction to FCM
- Concept 05: Overview of the Starting Code
- Concept 06: Quiz: Add an Instructor
- Concept 07: What is Firebase?
- Concept 08: Make a New Firebase Project
- Concept 09: Exercise: Connect Firebase and the Squawker App
- Concept 10: Exercise: Send Your First FCM Message
- Concept 11: Exercise: Introduction to Message Data
- Concept 12: Exercise: Sending to a Specific Phone
- Concept 13: Notification vs. Data Messages
- Concept 14: Exercise: Create Firebase Messaging Service
- Concept 15: Foreground vs. Background
- Concept 16: Sending to Multiple Devices
- Concept 17: Topics for Squawker
- Concept 18: Exercise: Implement Topic Following
- Concept 19: There's More to Learn about FCM
- Concept 20: FCM Outro
-
Lesson 05: Places
In this lesson, you'll learn how Android locates its device in the globe using GPS and other techniques. You will get to use Geofences to trigger actions when the device enters or exits a location
- Concept 01: Introduction to Places
- Concept 02: ShushMe Source Code
- Concept 03: How Location Works
- Concept 04: Google Play Services
- Concept 05: API Key Setup Instructions
- Concept 06: Including the API Key
- Concept 07: API Documentation
- Concept 08: Starter Code
- Concept 09: Google API Client
- Concept 10: Exercise: GoogleAPIClient
- Concept 11: Place Picker
- Concept 12: Exercise: Place Picker
- Concept 13: Get Place by ID
- Concept 14: Places API: Privacy and Attribution
- Concept 15: Exercise: GetPlaceById
- Concept 16: Geofences
- Concept 17: Geofencing vs. GPS Polling
- Concept 18: Geofencing
- Concept 19: Geofence Transitions
- Concept 20: Exercise: Geofences
- Concept 21: Tips and Tricks for Testing Location Apps
- Concept 22: Exercise: Silent Mode
- Concept 23: Places Outro
-
Lesson 06: Media Playback
In this lesson, you'll learn about Media Playback by implementing the ExoPlayer library in a music quiz app. You'll also learn about background playback, external clients, media sessions and more!
- Concept 01: Introduction to Media Playback
- Concept 02: Player UI Structure
- Concept 03: Audio Video
- Concept 04: Comparing Players
- Concept 05: Media Formats
- Concept 06: Exercise: Download Starting Code
- Concept 07: Starting Code Overview
- Concept 08: Add ExoPlayer Intro
- Concept 09: Exercise: Add SimpleExoPlayerView
- Concept 10: Exercise: Customize SimpleExoPlayerView
- Concept 11: Exercise: ExoPlayer Event Listening
- Concept 12: Add Media Session - Part 1
- Concept 13: ExoPlayer Event
- Concept 14: Exercise: Add Media Session - Part 2
- Concept 15: Exercise: MediaStyle Notification
- Concept 16: Introduction to Audio Focus and Extra ExoPlayer Features
- Concept 17: Audio Focus and Extra ExoPlayer Features
-
Lesson 07: Widgets
In this lesson you will get to create an app widget that can be placed in the home screen. Widgets are shortcuts that can display updated information from the app and handle click events.
- Concept 01: Introduction to Widgets
- Concept 02: What is an App Widget
- Concept 03: My Garden App
- Concept 04: PlantUtils Code
- Concept 05: Creating Your First App Widget
- Concept 06: RemoteViews
- Concept 07: My Garden Widget
- Concept 08: Exercise: Create a Simple Widget
- Concept 09: Widget Margins
- Concept 10: Background Tasks for Widgets
- Concept 11: WateringService
- Concept 12: Exercise: Add a Watering Service
- Concept 13: Widget Updates via IntentServices
- Concept 14: Exercise: UpdateWidgets Service
- Concept 15: Water Individual Plants
- Concept 16: Sending Extras to IntentService
- Concept 17: Exercise: Adding More Features
- Concept 18: Resizing Widgets
- Concept 19: AppWidgetManager Options
- Concept 20: GridViews in Widgets
- Concept 21: PendingIntent Templates
- Concept 22: Exercise: GridView
- Concept 23: Widgets Summary
-
Lesson 08: Espresso
This lesson will teach you all about Espresso, Android's testing framework that simplifies writing UI tests. We will cover testing basic Views, AdapterViews, Intents, and IdlingResources.
- Concept 01: Is that Espresso in My Tea?
- Concept 02: Quiz: Welcome to the World of Testing
- Concept 03: Welcome to the World of Testing
- Concept 04: Quiz: TeaTime Starting Code Walkthrough
- Concept 05: Exercise: Write a Basic Espresso Test
- Concept 06: Exercise: Test AdapterViews with Espresso
- Concept 07: Test Intents with Espresso
- Concept 08: Intent Stubbing vs. Intent Verification
- Concept 09: Intent Stubbing Code Example
- Concept 10: Intent Verification Code Example
- Concept 11: Exercise: Add Intent Test in TeaTime
- Concept 12: Introduction to Espresso Idling Resources
- Concept 13: When to Use Idling Resources
- Concept 14: Idling Resource Code Sample - Part 1
- Concept 15: Idling Resource Code Sample - Part 2
- Concept 16: Basic Idling Resource Code Sample
- Concept 17: Return via Callback in MainActivity
- Concept 18: Add Idling Resource Test in Sample App
- Concept 19: Exercise: Add IdlingResourceActivityTest in TeaTime
- Concept 20: Explore Espresso Further
- Concept 21: The Wider World of Testing
- Concept 22: Espresso Outro
-
Lesson 09: Publishing Your App
This lesson will walk you through all the steps to set up your app for success, publish your app, and continue to grow your audience post-launch in Google Play!
- Concept 01: Introduction to Publishing
- Concept 02: Publishing Process
- Concept 03: Exercise: Publishing Process
- Concept 04: Exercise: Policy Agreements
- Concept 05: Exercise: Quality Testing
- Concept 06: Exercise: Determining App Setup
- Concept 07: Prep for Release-Ready APK
- Concept 08: Exercise: Prep for Release-Ready APK
- Concept 09: Exercise: Configuring Your App for Release
- Concept 10: Exercise: Building Your App for Release
- Concept 11: Exercise: Testing Your App for Release
- Concept 12: Alpha/Beta Testing
- Concept 13: Exercise: Alpha/Beta Testing
- Concept 14: Pre-Launch Report
- Concept 15: Exercise: Store Listing, Play Badge & Linking
- Concept 16: Exercise: You're Ready to Publish!
- Concept 17: Exercise: Engage and Grow User Base
- Concept 18: Success on Google Play
-
-
Module 02: Project: Baking App
-
Lesson 01: Baking App
Create an app to view video recipes. You will handle media loading, verify your user interfaces with UI tests, integrate third party libraries and provide a complete UX with home screen widget.
-
Part 05 (Career): Career: Networking
Networking is a very important component to a successful job search. In the following lesson, you will learn how tell your unique story to recruiters in a succinct and professional but relatable way.
-
Module 01: Develop Your Personal Brand
-
Lesson 01: Develop Your Personal Brand
In this lesson, learn how to tell your unique story in a succinct and professional way. Communicate to employers that you know how to solve problems, overcome challenges, and achieve results.
-
Lesson 02: LinkedIn Review
Optimize your LinkedIn profile to show up in recruiter searches, build your network, and attract employers. Learn to read your LinkedIn profile through the lens of a recruiter or hiring manager.
-
Lesson 03: Udacity Professional Profile
Update and personalize your Udacity Professional Profile as you complete your Nanodegree program, and make your Profile visible to Udacity hiring partners when you’re ready to start your job search.
-
-
Module 02: GitHub Profile Review
-
Lesson 01: GitHub Review
Review how your GitHub profile, projects, and code represent you as a potential job candidate. Learn to assess your GitHub profile through the eyes of a recruiter or hiring manager.
- Concept 01: Introduction
- Concept 02: GitHub profile important items
- Concept 03: Good GitHub repository
- Concept 04: Interview with Art - Part 1
- Concept 05: Identify fixes for example “bad” profile
- Concept 06: Quick Fixes #1
- Concept 07: Quick Fixes #2
- Concept 08: Writing READMEs with Walter
- Concept 09: Interview with Art - Part 2
- Concept 10: Commit messages best practices
- Concept 11: Reflect on your commit messages
- Concept 12: Participating in open source projects
- Concept 13: Interview with Art - Part 3
- Concept 14: Participating in open source projects 2
- Concept 15: Starring interesting repositories
- Concept 16: Outro
- Concept 17: Resources in Your Career Portal
-
Part 06 : Gradle for Android and Java
Learn how the Gradle build tool compiles and packages apps, how to customize the build process, and uncover the magic that happens after you hit the "Run" button in Android Studio. You'll also explore advanced Android topics, learning to configure free vs. paid app flavors, create and integrate Android libraries, test your app, and prepare your app for Google Play.
-
Module 01: Gradle for Android and Java
-
Lesson 01: Gradle Fundamentals
Learn the syntax and semantics of Gradle build scripts, and understand the lifecycle of a Gradle build.
- Concept 01: Welcome to Gradle for Android and Java!
- Concept 02: Java and Android Builds
- Concept 03: Build Tool Advantages
- Concept 04: Why Gradle
- Concept 05: Intro to Tasks
- Concept 06: Command Line Gradle
- Concept 07: Run Your First Task
- Concept 08: Gradle Installation
- Concept 09: Install Gradle
- Concept 10: Gradle Build Scripts
- Concept 11: Groovy Fundamentals
- Concept 12: Groovy Closures and Objects
- Concept 13: Experiment with Groovy
- Concept 14: Task Configuration
- Concept 15: Configure a Task
- Concept 16: Task Dependencies and Ordering
- Concept 17: Configure Task Dependencies
- Concept 18: Typed Tasks
- Concept 19: Gradle DSL Reference
- Concept 20: Docs Scavenger Hunt
- Concept 21: Interacting With The File System
- Concept 22: Configure File System Tasks
- Concept 23: Incremental Builds
- Concept 24: Explore Incremental Builds
- Concept 25: Parameterising Your Build
- Concept 26: Gradle Properties
- Concept 27: Creating Custom Task Types
- Concept 28: Create Your Own Task Type
- Concept 29: Troubleshooting and Logging
- Concept 30: Investigate Logging
- Concept 31: Build Lifecycle
- Concept 32: Explore the Build Lifecycle
- Concept 33: On to Java!
-
Lesson 02: Gradle for Java
Understand the Gradle Java plugin, build and test Java projects, and manage dependencies.
- Concept 01: Super Spy Plugin
- Concept 02: Gradle Plugins
- Concept 03: Plugin Capabilities
- Concept 04: Java Build Tasks
- Concept 05: Applying the Java Plugin
- Concept 06: Create a JAR
- Concept 07: Conventions and Configuration
- Concept 08: Java Plugin Documentation
- Concept 09: Java Task Dependencies
- Concept 10: Configure the Java Plugin
- Concept 11: Dependency Management
- Concept 12: Repositories and Dependencies
- Concept 13: Working with Repositories
- Concept 14: Declaring Dependencies
- Concept 15: Declare Dependencies
- Concept 16: Dependency Reports
- Concept 17: Configurations
- Concept 18: Create a Custom Configuration
- Concept 19: Automated Testing
- Concept 20: Java Unit Testing
- Concept 21: Run Unit Tests
- Concept 22: Finding Gradle Plugins
- Concept 23: Advanced Gradle Wrapper
- Concept 24: Configure The Gradle Wrapper
- Concept 25: On to Android
-
Lesson 03: Gradle for Android
Discover the Gradle integration with Android Studio, and build an app with multiple product flavors.
- Concept 01: The Command-Line Cowboy
- Concept 02: Android Studio, Gradle, and Variants
- Concept 03: Android Studio
- Concept 04: Importing Gradle Projects
- Concept 05: Import a Java Project
- Concept 06: The Android Plugin
- Concept 07: Android Build Scripts
- Concept 08: Android Gradle Plugin Update
- Concept 09: Android Plugin Functionality
- Concept 10: Build Types, Flavors, and Variants
- Concept 11: Configuring Build Types
- Concept 12: Configure Build Types
- Concept 13: Resource Merging
- Concept 14: Declaring Flavors
- Concept 15: Declare Flavors
- Concept 16: Add a Flavor Specific Activity
- Concept 17: Per-Variant Dependency Configurations
- Concept 18: Flavor Dimensions
- Concept 19: Configuring Generated Tasks
- Concept 20: On to Advanced Android Builds
-
Lesson 04: Advanced Android Builds
Create Android libraries, and use advanced features of the Android Gradle Plugin to configure signing, obfuscation, and testing.
- Concept 01: Building like Doctor Octopus
- Concept 02: Libraries and Android Plugin Features
- Concept 03: Library Overview
- Concept 04: Android vs Java Libraries
- Concept 05: Multi-Project Builds
- Concept 06: Creating a Java Library
- Concept 07: Create Java Libraries
- Concept 08: Creating an Android Library
- Concept 09: Create an Android Library
- Concept 10: Wizards and Black Magic
- Concept 11: Application Signing
- Concept 12: Configuring Signing
- Concept 13: Configure Signing
- Concept 14: Multidex Support
- Concept 15: Configuring Proguard
- Concept 16: Android Testing
- Concept 17: Setting Up Android Tests
- Concept 18: Set Up Android Tests
- Concept 19: Congratulations!
-
Lesson 05: Special Topics
Learn how to update old projects and libraries and get more examples of custom tasks and multi-module projects.
-
-
Module 02: Project: Build It Bigger
-
Lesson 01: Build It Bigger
Build and test a joke telling app with a free ad-supported version and a paid version. As a bonus, deploy a Google Cloud Messaging backend to supply the jokes.
-
Part 07 : Material Design for Android Developers
Learn how to apply the material design principles that define Android's visual language to your apps. After a walk-through of Android design fundamentals, you'll see how to apply this knowledge to transform design elements of sample apps, giving you the background you need to create and use material design elements, surfaces, transitions and graphics in your app, across multiple form factors.
-
Module 01: Material Design for Android Developers
-
Lesson 01: Android Design Fundamentals
Understand and apply the fundamentals of Android design to your app, and experiment with app structures, common navigation patterns and themes.
- Concept 01: Introduction
- Concept 02: Physical and Density Independent Pixels
- Concept 03: Working with Density Independent Pixels
- Concept 04: More about Pixel Densities
- Concept 05: Calculating Dips
- Concept 06: Small Screens First
- Concept 07: Density buckets
- Concept 08: Density for Asset Crispness
- Concept 09: Vector vs Bitmap
- Concept 10: Dissecting the Resource Qualifier
- Concept 11: State Lists
- Concept 12: Layouts
- Concept 13: Getting Started with Layouts
- Concept 14: All about layouts
- Concept 15: Identifying Layouts
- Concept 16: Identifying Layouts Quiz
- Concept 17: Common Design Patterns
- Concept 18: Todo List Entities
- Concept 19: Thinking about Entities
- Concept 20: Introduction to Themes and Styles
- Concept 21: Adding a style
- Concept 22: Creating your own style
- Concept 23: Recap
-
Lesson 02: Surfaces
Understand how to use surfaces to structure the hierarchy and interaction of elements in an app.
- Concept 01: Overview Paper and Ink
- Concept 02: Tangibility
- Concept 03: Introduction to Surfaces
- Concept 04: Intuitive Hierarchy
- Concept 05: Using Surfaces
- Concept 06: Implementing Surfaces
- Concept 07: Making Surfaces
- Concept 08: Standard Elevation
- Concept 09: What is a Fab
- Concept 10: What should be a FAB
- Concept 11: Adding a FAB
- Concept 12: Surface Reaction
- Concept 13: Adding Ripple/Surface Elevation to a FAB
- Concept 14: Transforming Paper
- Concept 15: Creating Paper Transformations
- Concept 16: Responding to Scroll Events
- Concept 17: Making Scrollable Dynamic Surfaces
- Concept 18: How Surfaces Move
- Concept 19: Lesson Recap
- Concept 20: The Google Logo
-
Lesson 03: Bold Graphic Design
Understand and apply branding guidelines -- including key lines, metrics, fonts, typographic scale, color palette and themes/styles.
- Concept 01: Introduction
- Concept 02: Gestalt Principles Primer
- Concept 03: Gestalt Primer Continues
- Concept 04: Grids and Keylines
- Concept 05: Metrics
- Concept 06: Introducing Color and the Material Design Palette
- Concept 07: Using Color
- Concept 08: Color Palette
- Concept 09: Applying a Color Palette
- Concept 10: Pick The Best Accent Color
- Concept 11: Picking a Palette From an Image
- Concept 12: All About Typography
- Concept 13: Text Scale
- Concept 14: Scale Independent Pixels
- Concept 15: Font Characteristics
- Concept 16: Font Weight and Style
- Concept 17: How to Pick Fonts
- Concept 18: Adding a Custom Font
- Concept 19: All About Images
- Concept 20: Using imagery
- Concept 21: Making Images More Immersive
- Concept 22: Circular Avatars
- Concept 23: Aspect Ratio Images
- Concept 24: Background Protection
- Concept 25: Lesson Recap
- Concept 26: The Subculture of Android Design
-
Lesson 04: Meaningful Motion
Understand the use of motion in apps, how to use transitions to change app states and properly choreograph the motion in an app.
- Concept 01: Introduction
- Concept 02: Animation on Android
- Concept 03: Introduction to Transition Manager
- Concept 04: Transition Manager Quiz
- Concept 05: Newer Animation APIs
- Concept 06: Activity and Fragment Transitions in Lollipop
- Concept 07: Activity Enter and Exit
- Concept 08: Transitions Quiz
- Concept 09: Continuous State Changes
- Concept 10: Explaining Shared Element Transitions
- Concept 11: Implementing Shared Element Transitions
- Concept 12: Instructive Motion
- Concept 13: Implementing Instructive Motion
- Concept 14: Design to Enhance
- Concept 15: Interpolating
- Concept 16: Coordinated Motion
- Concept 17: Motion enhances your design
- Concept 18: Delightful Details
- Concept 19: Introduction to AnimatedVectorDrawables
- Concept 20: Implementing AnimatedVectorDrawables
- Concept 21: Lesson Recap
-
Lesson 05: Adaptive Design
Understand how to refine and test your designs on for use on multiple form factors.
- Concept 01: Introduction
- Concept 02: Problem Statement
- Concept 03: Examples of Non Optimal Tablet UIs
- Concept 04: How is this Tablet UI Non Optimal
- Concept 05: Breakpoints and Content First
- Concept 06: How to implement breakpoints
- Concept 07: Techniques for Managing Space
- Concept 08: What to vary at your Breakpoints
- Concept 09: What to Vary Part 2
- Concept 10: What to Vary Part 3
- Concept 11: Newly Optimized Tablet UIs
- Concept 12: Testing Validation
- Concept 13: Course Outro
-
Lesson 06: Constraint Layout
Learn and apply the new features of ConstraintLayout that will help you create performant user interfaces
- Concept 01: Introduction
- Concept 02: The Android View Rendering Cycle
- Concept 03: How Double Taxation Affects Views
- Concept 04: What is ConstraintLayout?
- Concept 05: The New Layout Editor
- Concept 06: Adding and Removing Constraints
- Concept 07: Understanding the New Attributes View
- Concept 08: Managing Space with Chains
- Concept 09: Helpful Tools For Designers
- Concept 10: Virtual Helper Objects
- Concept 11: Barriers
- Concept 12: Groups
- Concept 13: Placeholders
- Concept 14: Circular Positioning
- Concept 15: Conclusion
-
-
Module 02: Project
-
Lesson 01: Make Your App Material
In this project, you will update the look and feel of an app to meet Material Design specifications.
-
Part 08 (Career): Career: Android Interview Practice
Now that you've practiced your skills through your project work, learn how you can present your knowledge in an interview.
-
Module 01: Interview Practice (Android)
-
Lesson 01: Ace Your Interview
Learn strategies to prepare yourself for an interview.
-
Lesson 02: Practice Behavioral Questions
Practice answering behavioral questions and evaluate sample responses.
- Concept 01: Introduction
- Concept 02: Self-Practice: Behavioral Questions
- Concept 03: Analyzing Behavioral Answers
- Concept 04: Time When You Showed Initiative?
- Concept 05: What Motivates You at the Workplace?
- Concept 06: A Problem and How You Dealt With It?
- Concept 07: What Do You Know About the Company?
- Concept 08: Time When You Dealt With Failure?
-
Lesson 03: Interview Fails
Some real-life examples of interviews that didn't go as expected - it happens all the time!
-
Lesson 04: Land a Job Offer
You're practiced a lot for the interview by now. Continue practicing, and you'll ace the interview!
-
Lesson 05: Interview Practice
Walk through an example Android interview and find out how you can improve!
- Concept 01: Analyzing an Interview
- Concept 02: Mobile Interviewing Introduction
- Concept 03: Tech Interviews at Different Companies
- Concept 04: What to Look for in an Android Candidate
- Concept 05: Content Providers
- Concept 06: Implicit and Explicit Intents
- Concept 07: Device Rotation
- Concept 08: Design a Min Stack
- Concept 09: Application Not Responsive Error
- Concept 10: ListView Loading Slowly
- Concept 11: Interviewer's Overall Thoughts
- Concept 12: Additional Advice from Eric
- Concept 13: Keep Practicing!
- Concept 14: Resources in Your Career Portal
-
Part 09 : Capstone Project
Integrate all you've learned in this program to bring your own app idea to life. You will complete this project in two stages: design and build.
-
Module 01: Project: Capstone, Stage 1
-
Lesson 01: Capstone, Stage 1
Take the skills that you've learned and apply them to an app idea of your own. Design and plan your app, and receive feedback prior to building it in Stage 2.
-
-
Module 02: Project: Capstone, Stage 2
-
Lesson 01: Capstone, Stage 2
Take the skills that you've learned and apply them to designing your own app. You will execute on your vision and build your app in Stage 2.
-
-
Module 03: Final Steps
-
Lesson 01: Final Steps
Finish up and get ready to graduate!
-
Part 10 (Elective): Firebase
Learn to leverage Firebase, a platform to help you support and extend your app. Use Firebase's suite of complementary products -- including analytics, a cloud database, authentication, messaging, and more -- to develop, grow and monetize your apps.
-
Module 01: Firebase in a Weekend
-
Lesson 01: Saturday
Start the weekend off right by implementing Firebase in FriendlyChat. FriendlyChat is a realtime messaging application.
- Concept 01: Weekend Plans
- Concept 02: Course Contents
- Concept 03: Favorite Features
- Concept 04: Examination of the Final App
- Concept 05: Creating a Firebase Project
- Concept 06: Download the Friendly Chat App
- Concept 07: Firing Up FriendlyChat
- Concept 08: Create a Firebase Project for Android
- Concept 09: Finish Creating a Firebase Project for Android
- Concept 10: Starter Code Walkthrough
- Concept 11: Starter Code Walkthrough Exercise
- Concept 12: Add Firebase SDK
- Concept 13: Firebase Realtime Database
- Concept 14: Why Firebase Realtime Database?
- Concept 15: Database Structure
- Concept 16: Exploring the Database
- Concept 17: Database Implementation - Writing 1
- Concept 18: Database Implementation - Writing 2
- Concept 19: Database Implementation - Writing 3
- Concept 20: Database Rules for Testing
- Concept 21: Reading from the Firebase Realtime Database
- Concept 22: Database Implementation - Reading
- Concept 23: Database Implementation - Reading Conclusion
- Concept 24: Database Rules for Testing
- Concept 25: Database Security
- Concept 26: Database Security Rules
- Concept 27: Advanced Database Rules
- Concept 28: Why is it Great to Authenticate?
- Concept 29: Why is it Great to Authenticate? (Exercise)
- Concept 30: FirebaseUI Authentication
- Concept 31: Authentication in the Console
- Concept 32: Getting Started with FirebaseUI
- Concept 33: Authentication Overview
- Concept 34: AuthStateListener and AuthUI
- Concept 35: Signing In FriendlyChat
- Concept 36: Handling Cancelled Sign In
- Concept 37: Auth in app - Signing Out
- Concept 38: Saturday Check In
-
Lesson 02: Sunday
During the Sunday lesson, you'll be getting into more advanced topics, like using Firebase Storage to allow users to upload picture messages from their phone, and sending notifications.
- Concept 01: Sunday Funday
- Concept 02: Firebase Storage Features
- Concept 03: Creating Storage Structure
- Concept 04: Storage Implementation Overview
- Concept 05: Open Photo Picker
- Concept 06: Add Image to Storage
- Concept 07: Add Storage Reference
- Concept 08: Store and Display Images
- Concept 09: Keep your Stuff Safe
- Concept 10: Not your Parents’ Permissions
- Concept 11: Playing Matchmaker
- Concept 12: Playing Matchmaker Exercise
- Concept 13: Security Rules!
- Concept 14: Follow the Rules
- Concept 15: Contexts or Chaos
- Concept 16: Reading in Context
- Concept 17: Securing it All Together
- Concept 18: Analytics Answer “Now What?”
- Concept 19: Analyze This
- Concept 20: Notify Me
- Concept 21: Notifications - Receiving a Message
- Concept 22: Receive a Notification
- Concept 23: Remote Config: Little Changes, Big Impact
- Concept 24: Policies and Limits
- Concept 25: Talking Too Much
- Concept 26: Key-Value Storage on Fire
- Concept 27: Remote Config - Conclusion
- Concept 28: Making Firebase Your Homebase
-
Lesson 03: Monday
Got extra time this weekend? Write your own Cloud Function for Firebase that makes chat more fun by adding emojis to FriendlyChat conversations.
- Concept 01: Intro to Monday Module
- Concept 02: Java to JavaScript Comparison
- Concept 03: Intro to Cloud Functions
- Concept 04: Install the Firebase CLI
- Concept 05: Create the Local Project
- Concept 06: Cloud Functions Structure
- Concept 07: Function with Realtime Database
- Concept 08: Deploy and Test
- Concept 09: Emojify in FriendlyChat App
- Concept 10: More Functions
- Concept 11: Cloud Functions Conclusion
-
-
Module 02: Firebase Analytics
-
Lesson 01: Introduction to Digital Analytics
In this lesson, we will take on the role of the developer for a live app: Flood-It! We will discuss the foundations of digital analytics using Flood-It! as a model.
- Concept 01: How Does Your Garden Grow?
- Concept 02: Course Outline
- Concept 03: Analytics: Let the Data Drive
- Concept 04: Check out Flood-It!
- Concept 05: Download Flood-It!
- Concept 06: Demo of Flood-It!
- Concept 07: Measurement Planning
- Concept 08: Goal of Measurement Planning
- Concept 09: Identifying Goals
- Concept 10: Go for the Goals
- Concept 11: The Plan
- Concept 12: Meet Goals with In-App Purchases
- Concept 13: Planning
- Concept 14: Planning - Conclusion
- Concept 15: The Plan for Your Goals
- Concept 16: Are We There Yet?
- Concept 17: KPI
- Concept 18: KPI for Flood-It!
- Concept 19: Analytics in Action
-
Lesson 02: Introduction to Firebase Analytics
Learn about the Firebase Analytics Dashboard and how to view the data collected by your apps. Also, learn how to build audiences and funnels by leveraging events with Firebase Analytics.
- Concept 01: Intro: Flood-It!
- Concept 02: Firebase Analytics Intro
- Concept 03: Analytics for Flood-It!
- Concept 04: Access Demo Project
- Concept 05: Date Range and Filters
- Concept 06: Quiz: Date Range and Filters
- Concept 07: Dashboard Reports
- Concept 08: Exploring Analytics Events
- Concept 09: Quiz: Events Scavenger Hunt
- Concept 10: Tracking Events
- Concept 11: Automatically Collected Events
- Concept 12: Conversion Events
- Concept 13: Conversion Events in Flood It
- Concept 14: Audiences
- Concept 15: Funnels
- Concept 16: Design a Funnel
- Concept 17: Summary: Flood-It!
-
Lesson 03: Implementing In-App Analytics
Learn how to use built-in events provided by Firebase Analytics and implement some of your own. Then, see how easy it is to tailor an app experience to segments of users with User Properties.
- Concept 01: Intro: Implementing In-App Analytics
- Concept 02: Introducing the Green Thumb App
- Concept 03: Setting Up Green Thumb
- Concept 04: Running the App
- Concept 05: Firebase Automatically Collected Events
- Concept 06: Suggested Events
- Concept 07: Logging Events
- Concept 08: Exercise: Implementing Log to Cart Event
- Concept 09: Exercise: Event Logging Practice
- Concept 10: User Properties - Part 1
- Concept 11: User Properties - Part 2
- Concept 12: Setting User Properties
- Concept 13: Exercise: Setting User Properties
- Concept 14: Summary: Implementing In-App Analytics
-
Lesson 04: Analytics Integration
In this lesson, you'll build upon what you've learned about Firebase Analytics and explore crash reporting, remote configuration, and dynamic links — a suite of powerful tools for improving your apps.
- Concept 01: Intro: Analytics Integration
- Concept 02: Track Certain Groups of Users with Audiences
- Concept 03: Create an Audience
- Concept 04: Using Audiences
- Concept 05: Fix Crashes with Crash Reporting
- Concept 06: Crash Reporting in Green Thumb
- Concept 07: Exercise: Crash Reporting in Green Thumb
- Concept 08: Improve Your App with Remote Config
- Concept 09: Remote Config in Green Thumb
- Concept 10: Exercise: Remote Config in Green Thumb
- Concept 11: Tailored First-Time User Experience with Dynamic Links
- Concept 12: Dynamic Links in Console
- Concept 13: Dynamic Links in Green Thumb
- Concept 14: Exercise: Handle Dynamic Links
- Concept 15: Summary: Analytics Integration
- Concept 16: Conclusion
-