Nanodegree key: nd803
Version: 1.0.0
Locale: en-us
Learn Java and start building amazing new apps for those billion (and counting!) Android devices!
Content
Part 01 : Android Basics: User Interface
Learn how to transform your hand-drawn app designs into layouts using the XML markup language, and use Views and ViewGroups --
the building blocks of an Android app's user interface -- to display images and text.
-
Module 01: Nanodegree Introduction
-
Lesson 01: Welcome to the Nanodegree
Get ready to start your Nanodegree Adventure!
-
-
Module 02: Classroom Introduction
-
Module 03: User Interface
-
Lesson 01: Building Layouts: Part 1
Learn how to place layouts on a page to create images, buttons, and text on a phone screen
- Concept 01: Welcome to the Course
- Concept 02: Introduction
- Concept 03: Preparing for the Journey Ahead
- Concept 04: Quiz: Views
- Concept 05: Quiz: Picking Views for YouTube App
- Concept 06: Talking To Your Phone
- Concept 07: Quiz: Using a TextView
- Concept 08: XML Syntax
- Concept 09: Quiz: Change the TextView
- Concept 10: Quiz: Getting Past Errors
- Concept 11: Quiz: Setting Wrap Content
- Concept 12: Quiz: TextView Text Size
- Concept 13: Quiz: TextView Text Color
- Concept 14: Quiz: Simple ImageView
- Concept 15: Quiz: Documentation
- Concept 16: Chatting with Google's Kirill Grouchnikov
-
Lesson 02: Quick Check In
Got a handle of Views? Feeling the XML Love? Awesome … but you've just scratched the surface of what is possible. Onwards!
-
Lesson 03: Building Layouts: Part 2
Learn how grouping layouts together allows for more creative and original designs
- Concept 01: ViewGroups
- Concept 02: Quiz: Types of ViewGroups
- Concept 03: LinearLayout
- Concept 04: Width and Height
- Concept 05: Evenly Spacing Out Children Views
- Concept 06: Layout Weight
- Concept 07: Relative Layout
- Concept 08: Relative to Parent
- Concept 09: Relative to Other Views
- Concept 10: List Item with RelativeLayout
- Concept 11: Padding vs. Margin
- Concept 12: Chatting with Google's Kirill Grouchnikov Part 2
-
Lesson 04: Practice Set: Building Layouts
Download Android Studio and get your first designs onto an actual phone
- Concept 01: Welcome to the Practice Set
- Concept 02: The Installation Process
- Concept 03: Troubleshooting
- Concept 04: Install Java: Windows Guide
- Concept 05: Install Java: Mac Guide
- Concept 06: Install Android Studio
- Concept 07: Windows: Guide to Install Android Studio
- Concept 08: Mac: Guide to Install Android Studio
- Concept 09: Discussion about Constraint Layout
- Concept 10: Hello World
- Concept 11: Hello World: Written Instructions
- Concept 12: A Quick Tour of Android Studio
- Concept 13: Running Hello World on Your Phone
- Concept 14: Using the Emulator
- Concept 15: Create the Birthday Card App
- Concept 16: RelativeLayout LinearLayout
- Concept 17: The Drawable Folder
- Concept 18: Positioning
- Concept 19: Styling
- Concept 20: Make the Text Larger
- Concept 21: Setting the Font
- Concept 22: Setting the Color
- Concept 23: Attributes for the ImageView
- Concept 24: How to Style the Image
- Concept 25: Minor Adjustments
- Concept 26: Recap
- Concept 27: Make your Own Card
- Concept 28: Intro to Study Break: Charity Miles
- Concept 29: Study Break: Charity Miles
- Concept 30: Great Work!
- Concept 31: Learn More On Your Own
-
-
Module 04: Project
-
Lesson 01: Build a Single Screen App
Design and implement a simple app that displays information about a small business.
-
Part 02 : Android Basics: User Input
Harness the power of Java to build a coffee-ordering app, use variables to add interactivity to your app, and learn the basics of object-oriented programming.
-
Module 01: Android Basics: User Input
-
Lesson 01: Making an App Interactive: Part 1
Begin making your app interactive!
- Concept 01: Introduction
- Concept 02: Create a New Project
- Concept 03: Plan How to Build the Layout
- Concept 04: Build Layout
- Concept 05: Do Something When the Button is Clicked
- Concept 06: Modifying First Lines of Java Code
- Concept 07: Solving Math Problems
- Concept 08: Add TextViews for Price
- Concept 09: The Need for Variables
- Concept 10: Add Your First Variable
- Concept 11: Sometimes things don’t go as expected
- Concept 12: Debugging a Crash
- Concept 13: Chatting with Google's Alice Yang, Part 1
- Concept 14: Hook Up Two Buttons
- Concept 15: Debug Mode in Android Studio
- Concept 16: Update Data
- Concept 17: Update a Variable in the App
- Concept 18: Update Quantity Variable
- Concept 19: Modify the increment() Method
- Concept 20: Modify the decrement() Method
- Concept 21: Make the Quantity Picker Work
- Concept 22: Fix the Order Button
- Concept 23: Reflection
-
Lesson 02: Making an App Interactive: Part 2
- Concept 01: Plan Layout for Quantity Picker
- Concept 02: Nested ViewGroups
- Concept 03: View Hierarchy Diagrams
- Concept 04: Choosing the Right XML Layout
- Concept 05: Build the Quantity Picker Layout
- Concept 06: String Data Type
- Concept 07: Create the String Variable
- Concept 08: Combining Strings Together
- Concept 09: Chatting with Google's Alice Yang, Part 2
- Concept 10: Combining String and Integer Variables
- Concept 11: Update the String Variable
- Concept 12: Congrats!
- Concept 13: Learn More on Your Own
-
Lesson 03: Practice Set: Making an App Interactive
Practice building interactivity and build your second project!
- Concept 01: Introduction to Practice Set
- Concept 02: Experimenting with the Code (OPTIONAL)
- Concept 03: Declare and Initialize
- Concept 04: Integer, integer, int
- Concept 05: currentlyPlaying Variable
- Concept 06: Profile Name
- Concept 07: Using Variables
- Concept 08: Travel Times
- Concept 09: Shopping List
- Concept 10: Shopping List, Once More...
- Concept 11: Currency Conversion
- Concept 12: Email Directory
- Concept 13: Scope
- Concept 14: Cola Wars 1
- Concept 15: Cola Wars 2
- Concept 16: Cola Wars 3
- Concept 17: Healthy Living Intro
- Concept 18: Healthy Living
- Concept 19: Court Counter Intro
- Concept 20: The Stages
- Concept 21: Setting up the Methods
- Concept 22: Planning Your Variables
- Concept 23: Create the Score Variable
- Concept 24: Plan to Update Score
- Concept 25: Updating Score
- Concept 26: Update with the Other Buttons
- Concept 27: Add the Other Team in XML
- Concept 28: Add The Other Team - Java
- Concept 29: Plan to Add the Reset Button
- Concept 30: Add the Reset Button
- Concept 31: Make it Pretty
- Concept 32: Recap
- Concept 33: Intro to Study Break: PulsePoint
- Concept 34: Study Break: PulsePoint
-
Lesson 04: Project: Score Keeper App
Implement an app to track scores between two teams playing a game.
-
Lesson 05: Object-Oriented Programming: Part 1
- Concept 01: Intro
- Concept 02: Defining vs Calling a Method
- Concept 03: Calculate Price Method
- Concept 04: Define a Method
- Concept 05: Inputs to a Method
- Concept 06: Add or Remove Parameters
- Concept 07: Output from a Method
- Concept 08: Use Return Value from Method
- Concept 09: Define and Call a Method
- Concept 10: The displayMessage Method
- Concept 11: Resources
- Concept 12: Resource IDs
- Concept 13: From XML to Java
- Concept 14: What Are Java Objects?
- Concept 15: What is a Java Class?
- Concept 16: Create an Object
- Concept 17: Call Methods on Object
- Concept 18: Practice Calling Object Methods
- Concept 19: Inheriting Behavior
- Concept 20: Find View by Id
- Concept 21: Casting with findViewById
- Concept 22: Set Data on Views
- Concept 23: Quiz: Read Data from Views
-
Lesson 06: Object-Oriented Programming: Part 2
- Concept 01: Adding a CheckBox
- Concept 02: Boolean Data Type
- Concept 03: Update Order Summary
- Concept 04: Scrolling Along
- Concept 05: Add Chocolate Topping
- Concept 06: Add the Chocolate Topping CheckBox
- Concept 07: Intro to Imposter Syndrome
- Concept 08: Googlers' Montage
- Concept 09: What's Your Name?
- Concept 10: Conditional Code
- Concept 11: Conditional Code (Email)
- Concept 12: Conditional Code (Smoothie)
- Concept 13: Introduction to If/Else
- Concept 14: Syntax of If/Else
- Concept 15: Relational Operators
- Concept 16: Adjust Price With Toppings
- Concept 17: Negative Cups of Coffee
- Concept 18: Let Someone Else Do the Hard Work
- Concept 19: Practice With Intents
- Concept 20: Localization (OPTIONAL)
- Concept 21: Styles
- Concept 22: Styles
- Concept 23: Themes
- Concept 24: Reflect on What You've Accomplished
- Concept 25: Intro to Study Break: Peek Vision
- Concept 26: Study Break: Peek Vision
- Concept 27: You're (Almost) Done!
- Concept 28: Congratulations!
-
Lesson 07: Quiz App
Design and implement a short quiz app about some topic you are familiar with.
-
Part 03 : Android Basics: Multi-Screen Apps
Learn how to show multiple screens in a Miwok language app, and add audio and images to your app. You'll also learn how Android handles touch events, and make visual changes to add polish to your fully functional app.
-
Module 01: Android Basics: Multi-Screen Apps
-
Lesson 01: Intents and Activities
Build the structure of the Miwok language app!
- Concept 01: Intro
- Concept 02: Course Map
- Concept 03: Overview of the Miwok App
- Concept 04: Quiz: Import an Existing Project
- Concept 05: Checking the build.gradle file
- Concept 06: Read MainActivity.java file
- Concept 07: Create New Activities
- Concept 08: The AndroidManifest.xml File
- Concept 09: Use an Intent to Open Another Activity
- Concept 10: Implicit vs. Explicit Intents
- Concept 11: Modifying the Activity Name
- Concept 12: Andrea Interview
- Concept 13: Event Listeners in Android
- Concept 14: Using Boxes To Explain OnClickListener
- Concept 15: What is an Interface?
- Concept 16: How to Create an Event Listener
- Concept 17: Use OnClickListeners For All Categories
- Concept 18: OnClickListener vs onClick
- Concept 19: Eric Gonzalez Interview
- Concept 20: Reflection
-
Lesson 02: (v1) Musical Structure
Create the structure of an app to play music for a user.
-
Lesson 03: Arrays, Lists, Loops, & Custom Classes
Use Arrays, Lists, and Loops to populate the Miwok app with words.
- Concept 01: Lesson 2 Course Map
- Concept 02: When to Use Arrays
- Concept 03: Working with an Array
- Concept 04: Add Words to NumbersActivity
- Concept 05: Verify Array Elements with Log Messages
- Concept 06: Working with An ArrayList
- Concept 07: Working with an ArrayList Quiz
- Concept 08: Switch from Array to ArrayList
- Concept 09: Add Text Views to the Layout Based on the List
- Concept 10: Intro to Loops
- Concept 11: Add TextViews to Layout with While Loop
- Concept 12: Use the For Loop
- Concept 13: Memory is a Limited Resource
- Concept 14: View Recycling
- Concept 15: Analogy for ListView
- Concept 16: Switch to Using ListView and ArrayAdapter
- Concept 17: Switch to Using a ListView and Adapter Quiz
- Concept 18: ListView and ArrayAdapter
- Concept 19: ListView and ArrayAdapter Code
- Concept 20: Andrea Interview
- Concept 21: Build List Item Layout
- Concept 22: Build List Item Layout Quiz
- Concept 23: When to Create a Custom Class
- Concept 24: Custom Word Class
- Concept 25: Custom Word Class Quiz
- Concept 26: Need a Custom ArrayAdapter
- Concept 27: Need a Custom ArrayAdapter Exercise
- Concept 28: Example App with Custom ArrayAdapter
- Concept 29: Custom ArrayAdapter
- Concept 30: Remaining Words
- Concept 31: Eric Gonzalez Interview
- Concept 32: Reflection
-
Lesson 04: Design a Report Card Class
Create a custom class to represent a report card app.
-
Lesson 05: Images and Visual Polish
Integrate images into your app.
- Concept 01: Lesson 3 Course Map
- Concept 02: Scope Out Work for a New Feature
- Concept 03: What Order to Make Changes In
- Concept 04: Modify List Item Layout
- Concept 05: Asset Drop
- Concept 06: Add Image Assets to the App
- Concept 07: Andrea Interview
- Concept 08: Plan How to Modify Word Class
- Concept 09: Modify Word Class
- Concept 10: Multiple Constructors for Word Class
- Concept 11: Modify the WordAdapter Class
- Concept 12: How Do We Fix PhrasesActivity
- Concept 13: Fix PhrasesActivity to Hide Images
- Concept 14: Visual Polish
- Concept 15: Plan How to Have Different Background Colors for List Items
- Concept 16: Different Background Colors for List Items
- Concept 17: Eric Gonzalez Interview
- Concept 18: Reflection
-
Lesson 06: Activity Lifecycle and Audio Playback
Use an external library to add audio to your app.
- Concept 01: Lesson 4 Course Map
- Concept 02: Plan How to Add the Audio Feature
- Concept 03: Music Player App
- Concept 04: MediaPlayer Class
- Concept 05: States of the Media Player Part 1
- Concept 06: States of the Media Player Part 2
- Concept 07: Challenge: Complete the Audio Feature
- Concept 08: Handling Touch Events On A ListView
- Concept 09: AdapterView
- Concept 10: Play One Audio File
- Concept 11: Add Remaining MP3 Files
- Concept 12: Which Audio File to Play
- Concept 13: Play Correct Audio File Per Word
- Concept 14: Andrea Interview
- Concept 15: The toString() Method (Optional)
- Concept 16: Async Callbacks in Android
- Concept 17: Cleaning Up Media Resources
- Concept 18: Understanding The Activity Lifecycle
- Concept 19: Understanding The Activity Callbacks
- Concept 20: Sample App With Lifecycle Callbacks
- Concept 21: MediaPlayer And Activity Lifecycle
- Concept 22: Learn About Audio Focus
- Concept 23: AudioManager Service
- Concept 24: Request Audio Focus
- Concept 25: Audio Focus States
- Concept 26: Manage Audio Focus in the App
- Concept 27: Add Audio Icon to List Item Layout
- Concept 28: Quiz: Touch Feedback for Clickable Views
- Concept 29: Pressed States on Category Views
- Concept 30: Pressed States on List Item Views
- Concept 31: Reflection
-
Lesson 07: (OPTIONAL) Fragments
Optional Lesson: Modify the structure of the Miwok app and make a smoother user experience
- Concept 01: Introduction
- Concept 02: Navigation Patterns in Android
- Concept 03: Navigation Patterns in Other Apps
- Concept 04: Up Button
- Concept 05: An Alternative Version of the App
- Concept 06: Android Development Patterns
- Concept 07: Upcoming Changes
- Concept 08: Sample ViewPager
- Concept 09: Intro to Fragments
- Concept 10: Fragment Lifecycle
- Concept 11: Refactor Category Activities
- Concept 12: ViewPager and FragmentPagerAdapter
- Concept 13: Add Tabs to ViewPager
- Concept 14: Congratulations!
-
Lesson 08: (v1) Tour Guide App
Create an app to guide a user around a city or location of your choice!
-
Part 04 : Android Basics: Networking
Discover the power of Web APIs and how to use them in your apps, and learn the basics of networking in Android, including HTTP networking, JSON parsing, and threads.
-
Module 01: Android Basics: Networking
-
Lesson 01: JSON Parsing
Learn how to parse JSON, one of the most useful data formats.
- Concept 01: Earthquake at the Coffee Shop
- Concept 02: Where to Find Earthquake Data?
- Concept 03: Receiving Mocks from Our Designer
- Concept 04: Course Map
- Concept 05: Explore USGS Website As A User
- Concept 06: Drive-Through Data
- Concept 07: Explore USGS Website As A Developer
- Concept 08: Import Existing Project
- Concept 09: Checking the build.gradle file
- Concept 10: Solution Code on GitHub
- Concept 11: Show more info on each earthquake
- Concept 12: Overview of JSON
- Concept 13: JSON Components
- Concept 14: Traverse Nodes in JSON Object Tree
- Concept 15: Parsing JSON in Android
- Concept 16: Look at Earthquake Query Result
- Concept 17: Traversing Earthquake JSON Object Tree
- Concept 18: Parse JSON response in Quake Report app
- Concept 19: Display date and time of earthquake
- Concept 20: Quiz: Display date and time of earthquake
- Concept 21: Split location into 2 TextViews
- Concept 22: Magnitude as a Decimal Value
- Concept 23: Switch Statement
- Concept 24: Circle Background for Magnitude
- Concept 25: Visual Polish
- Concept 26: Add Earthquake Intent
- Concept 27: Reflection
-
Lesson 02: HTTP Networking
Learn how to connect to the internet in your Android code.
- Concept 01: Intro
- Concept 02: Introduction to Networking
- Concept 03: Introduction to Networking Part 2
- Concept 04: Permissions in Android
- Concept 05: Request Internet Permission
- Concept 06: The HyperText Transfer Protocol (HTTP)
- Concept 07: Read Existing Code
- Concept 08: HTTP Request URL
- Concept 09: URL Object
- Concept 10: HttpURLConnection
- Concept 11: Android System Architecture
- Concept 12: HTTP Request Method Types
- Concept 13: GET Request in Soonami app
- Concept 14: Making the Connection
- Concept 15: HTTP Response Codes
- Concept 16: Check HTTP Response Code in Soonami App
- Concept 17: Reading From an Input Stream
- Concept 18: StringBuilder
- Concept 19: StringBuilder Part 2
- Concept 20: Exceptions
- Concept 21: Try/Catch/Finally block
- Concept 22: Practice with Try/Catch Statements
- Concept 23: Log errors
- Concept 24: Congratulations
-
Lesson 03: Threads & Parallelism
Learn how to use threads to make your device do multiple things at once!
- Concept 01: Intro
- Concept 02: "Did You Feel It?" App
- Concept 03: Main vs Background Threads 1
- Concept 04: Main vs Background Threads 2
- Concept 05: Main vs Background Threads 3
- Concept 06: AsyncTask to the Rescue
- Concept 07: AsyncTask Callback Methods
- Concept 08: Review of Generics
- Concept 09: AsyncTask Generic Params
- Concept 10: Inner Classes
- Concept 11: Fix the "Did You Feel It?" App
- Concept 12: Handle Empty or Null Cases
- Concept 13: Plan Changes to Quake Report App
- Concept 14: AsyncTask Generic Params in Quake Report App
- Concept 15: Networking in Quake Report App
- Concept 16: Limitations of AsyncTask
- Concept 17: Intro to Loaders, Part 1
- Concept 18: Intro to Loaders, Part 2
- Concept 19: Switch to Using a Loader
- Concept 20: Verify Loader Behavior
- Concept 21: Empty State of the List
- Concept 22: Loading Indicator
- Concept 23: No Internet Connection
- Concept 24: Check Network Connectivity Status
- Concept 25: Congrats
-
Lesson 04: Book Listing App
Create an app to list the published books on a given topic using the Google Books API.
-
Lesson 05: Preferences
Text-based lesson on preferences in Android.
- Concept 01: Intro to Preferences
- Concept 02: Intro to Fragments
- Concept 03: Making a Preference Screen
- Concept 04: Preference for Minimum Earthquake Magnitude
- Concept 05: Construct Desired URL from User Preferences
- Concept 06: Preference Summaries
- Concept 07: Preference for Sort Order of Earthquakes in List
-
Lesson 06: (v1) News App
Create an app to display recent news stories on a topic of your choice using an API.
-
Part 05 : Android Basics: Data Storage
Learn about the importance of data persistence when building an Android app. You'll also learn how to work with SQL databases and Content Providers, which help keep your data bug-free and allow you to share your data storage with other developers.
-
Module 01: Android Basics: Data Storage
-
Lesson 01: Database Basics
Learn how to use SQLite, the database system that runs on Android
- Concept 01: Intro
- Concept 02: Interview with Jessica
- Concept 03: Intro Part 2
- Concept 04: Course Map
- Concept 05: Design Mocks
- Concept 06: What's the problem?
- Concept 07: Why is Data Persistence Important?
- Concept 08: Computer Memory
- Concept 09: Different Data Storage Options
- Concept 10: Spreadsheets and Tables
- Concept 11: Tables
- Concept 12: Databases in Real Life
- Concept 13: SQLite Databases in Android
- Concept 14: Install SQLite
- Concept 15: Opening SQLite for the First Time
- Concept 16: Types in SQLite
- Concept 17: Design and Create a Database
- Concept 18: Quick SQL Tips
- Concept 19: CRUD overview
- Concept 20: CRUD Action Quiz A
- Concept 21: CRUD Action Quiz B
- Concept 22: CRUD Action Quiz C
- Concept 23: CRUD Action Quiz D
- Concept 24: CRUD Action Quiz E
- Concept 25: CRUD Action Quiz F
- Concept 26: CRUD Action Quiz G
- Concept 27: Insert data in a database and select it
- Concept 28: Quiz: Table Constraints
- Concept 29: Select, where, and order by
- Concept 30: UPDATE
- Concept 31: DELETE
- Concept 32: Recap Lesson
- Concept 33: Reflection
-
Lesson 02: Using a Database in an Android App
Learn how to use SQLite within your Android app.
- Concept 01: Intro to Lesson 2
- Concept 02: Import Existing Project
- Concept 03: Checking the build.gradle file
- Concept 04: Solution Code on GitHub
- Concept 05: Steps to Create a DB
- Concept 06: Identify Schema
- Concept 07: What is a Contract Class?
- Concept 08: Create the Contract
- Concept 09: Check Constant Names
- Concept 10: Create Database with SQLiteOpenHelper
- Concept 11: Getting a Database Connection
- Concept 12: Pull database file from device
- Concept 13: SQLite Database Object and Inserting Data
- Concept 14: Insert Dummy Pet from Menu Item
- Concept 15: Insert Pet From Editor
- Concept 16: Insert Pet from Editor Quiz
- Concept 17: Database Query Method
- Concept 18: SQL Injection Example
- Concept 19: What is a Cursor?
- Concept 20: Use Database Query Method
- Concept 21: Handling a Cursor object
- Concept 22: Read Values from Cursor
- Concept 23: Recap of Lesson 2
- Concept 24: Reflection
-
Lesson 03: Habit Tracker
Create an app to help users track and maintain healthy habits throughout their lives.
-
Lesson 04: Introduction to Content Providers
In this lesson, you'll learn the fundamentals of working with a ContentProvider.
- Concept 01: Intro to Content Providers
- Concept 02: Why Use Content Providers ?
- Concept 03: Use Case for Sharing Pet Data
- Concept 04: Diving into ContentProviders
- Concept 05: Add ContentProvider to Pets App
- Concept 06: ContentProvider Operations
- Concept 07: Design Pet Content URIs
- Concept 08: Which Content URI to Use?
- Concept 09: Add URIs to the Contract
- Concept 10: URI Matcher
- Concept 11: Add URIMatcher to ContentProvider
- Concept 12: Implement ContentProvider Query() Method - Instructions
- Concept 13: Implement ContentProvider Query() Method
- Concept 14: Using the ContentProvider Query() Method
- Concept 15: Use Case For Querying Pet Shelter Data
- Concept 16: Quiz: ConnectProvider insert() Method
- Concept 17: Sanity Checks
- Concept 18: Add Data Validation to ContentProvider
- Concept 19: ContentProvider update() Method
- Concept 20: ContentProvider delete() Method
- Concept 21: ContentProvider getType() Method
- Concept 22: Lesson Recap
- Concept 23: Contacts Provider
- Concept 24: Reflection
-
Lesson 05: Loading Data Using CursorLoader
In this lesson, you'll use adapters and loaders to move data from your ContentProvider to the user interface of your app.
- Concept 01: Intro to the Lesson
- Concept 02: Intro to CursorAdapter
- Concept 03: Implement a CursorAdapter
- Concept 04: Create the Empty View
- Concept 05: Intro to CursorLoader
- Concept 06: Using a CursorLoader
- Concept 07: Avoiding Unnecessary Reloads
- Concept 08: CursorLoader Automatically Loading
- Concept 09: Use EditorActivity for Editing Pets Too
- Concept 10: Load Existing Pet in EditorActivity
- Concept 11: Update Pet
- Concept 12: Prevent Crash with Blank Editor
- Concept 13: Warn the User About Unsaved Changes
- Concept 14: Hide the Delete Menu Option For New Pets
- Concept 15: Delete Pet From EditorActivity
- Concept 16: Delete All Pets Menu Option
- Concept 17: Unknown Breed
- Concept 18: Recap of Lesson 4
- Concept 19: Google Keep App
- Concept 20: Congratulations!
-
Lesson 06: (v1) Inventory App
Create an app to track the inventory of a retail store, including current stock and supplier information.
-