Nanodegree key: nd940
Version: 2.0.6
Locale: en-us
更多新课➕客服wx：udacity6Learn the latest in development technology using Android Studio
Content
Part 01 : Welcome to Android Kotlin Developer Nanodegree Program
-
Module 01: Welcome to Android Kotlin Developer Nanodegree Program
-
Lesson 01: Android Kotlin Developer Nanodegree Program Introduction
Introduction to Android Kotlin Developer program.
-
Lesson 02: Getting Help
You are starting a challenging but rewarding journey! Take 5 minutes to read how to get help with projects and content.
-
Part 02 : Developing Android Apps with Kotlin - Part 1
-
Module 01: Developing Android Apps with Kotlin - Part 1
-
Lesson 01: Build your First App
Build your first app: "Dice Roller" that covers basic Android components like displaying texts and images as well as a tour of the Android tools you'll be using throughout this course.
- Concept 01: Welcome To Developing Android Apps
- Concept 02: Looking Forward
- Concept 03: Dice Roller
- Concept 04: Installing Android Studio
- Concept 05: Creating the Dice Roller Project: Written Instructions
- Concept 06: Running Your First App
- Concept 07: Running your First App on an Emulator
- Concept 08: Running your First App on a Device
- Concept 09: Student Interview: Part 1
- Concept 10: Main App Anatomy
- Concept 11: Quiz: App Anatomy
- Concept 12: Activity and Layout
- Concept 13: Exercise: Hello Android
- Concept 14: Adding the Button
- Concept 15: Exercise: Adding the Button
- Concept 16: Connecting the Button
- Concept 17: Exercise: findViewById
- Concept 18: Exercise: OnClickListener
- Concept 19: Exercise: Change the Text
- Concept 20: Dice Images
- Concept 21: Exercise: Adding the Image Resource
- Concept 22: Exercise: Adding the ImageView
- Concept 23: Student Interview: Part 2
- Concept 24: Exercise: Finding Views Efficiently
- Concept 25: Namespaces
- Concept 26: Introduction to Gradle
- Concept 27: Build.gradle
- Concept 28: Android Compatibility
- Concept 29: Exercise: Vector Drawables
- Concept 30: Assessment
- Concept 31: Recap
-
Lesson 02: Layouts
Designing your app's UI is the first step to a great user experience. This lesson covers all the basics of UI layout design. You'll use all the popular view types with a focus on the ContraintLayout.
- Concept 01: Art with Aleks
- Concept 02: Introduction
- Concept 03: Looking Forward
- Concept 04: View Groups & View Hierarchy
- Concept 05: Exercise: Create the AboutMe Project
- Concept 06: Exercise: Create the Layout File
- Concept 07: Layout Editor Basics
- Concept 08: Adding a TextView
- Concept 09: Styling a TextView
- Concept 10: Exercise: Add a TextView, ImageView, and Styling
- Concept 11: Exercise: Add a ScrollView
- Concept 12: Adding an EditText for Text Input
- Concept 13: Adding a Done Button to Accept Text Input
- Concept 14: Exercise: Add EditText, Done Button, ClickHandler
- Concept 15: Data Binding
- Concept 16: Data Binding: Views
- Concept 17: Data Binding: Data
- Concept 18: Exercise: Implement Data Binding
- Concept 19: Google Interview: John Hoford and Nicolas Roard
- Concept 20: Constraint Layout: ColorMyViews App
- Concept 21: Creating ColorMyViews Project
- Concept 22: Exercise: Create ColorMyViews Project and One Box
- Concept 23: Constraints
- Concept 24: Ratios
- Concept 25: Chaining
- Concept 26: Adding Box Two Below Box One
- Concept 27: Adding Three Aligned Boxes
- Concept 28: Exercise: Add Aligned Boxes with Click Handlers
- Concept 29: Baseline Constraint
- Concept 30: Exercise: Add Baseline Constraint and Button Chain
- Concept 31: Assessment
- Concept 32: Where to Go Next?
-
Lesson 03: App Navigation
Building multiple screens on Android has never been easier with the Navigation library. You'll get to build a fun trivia app using multiple fragments and conditional navigation.
- Concept 01: The Guide and the Traveler
- Concept 02: Looking Forward
- Concept 03: Android Navigation Patterns
- Concept 04: Fragments
- Concept 05: Quiz: Fragment Basics
- Concept 06: Exercise: Project Tour
- Concept 07: Exercise: Creating and Adding a Fragment
- Concept 08: Navigation Component
- Concept 09: Exercise: Let’s Navigate Already
- Concept 10: Principles of Navigation
- Concept 11: Exercise: Conditional Navigation
- Concept 12: Exercise: Back Stack Manipulation
- Concept 13: Quiz: Back Stack Manipulation
- Concept 14: Exercise: Adding Support for the Up Button
- Concept 15: Android Navigation - Up vs Back
- Concept 16: Google Interview: Ian Lake
- Concept 17: Exercise: Adding a Menu
- Concept 18: Quiz: Matching Menu Attributes
- Concept 19: Exercise: Adding Safe Arguments
- Concept 20: Why do we have Safe Arguments?
- Concept 21: Intents and Sharing
- Concept 22: Quiz: Explicit vs Implicit Intents
- Concept 23: Exercise: Adding Sharing with an Intent
- Concept 24: Exercise: Adding the Navigation Drawer
- Concept 25: Summary of Navigation
- Concept 26: Quiz: How to Navigate
- Concept 27: Exercise: Using Navigation Listeners
- Concept 28: Exercise: Animation with Navigation
- Concept 29: Assessment
-
Lesson 04: Activity & Fragment Lifecycle
Understanding the concept of Lifecycles for both activities and fragments is what makes a great Android developer! Have a treat with this delicious "Dessert Pusher" app.
- Concept 01: The Case of the Missing Data
- Concept 02: Looking Forward
- Concept 03: Why Track Activity State?
- Concept 04: Exercise: Introduction to the Activity Lifecycle Diagram
- Concept 05: Exercise: Introduction to Logging
- Concept 06: Exercise: The Application Class and Timber
- Concept 07: Lifecycle: Open and Close
- Concept 08: Lifecycle: Share dialog
- Concept 09: onCreate vs onStart
- Concept 10: Activity Lifecycle States and Callbacks Summary
- Concept 11: Quiz: Activity
- Concept 12: Lifecycle: Navigate Away
- Concept 13: Quiz: Lifecycle
- Concept 14: Google Interview: Dianne Hackborn
- Concept 15: Exercise: Setup and Teardown
- Concept 16: Introduction to the Lifecycle Library
- Concept 17: Exercise: Lifecycle Observation
- Concept 18: Process Shutdown
- Concept 19: Process Shutdown Demo
- Concept 20: Exercise: onSaveInstanceState
- Concept 21: Configuration Changes
- Concept 22: The Future of Lifecycles
-
Lesson 05: App Architecture (UI Layer)
With Architecture Components you'll have the power to design even the most complicated app ideas. Combine ViewModels with LiveData to build this super fun "Guess it" game.
- Concept 01: Architecting on the Fly
- Concept 02: Looking Forward
- Concept 03: Lesson Introduction
- Concept 04: Exercise: Tour of the App
- Concept 05: Where the App Falls Short
- Concept 06: What is Architecture
- Concept 07: Our App Architecture
- Concept 08: ViewModel
- Concept 09: Quiz: ViewModel
- Concept 10: Exercise: Create the GameViewModel
- Concept 11: What Belongs in the GameViewModel?
- Concept 12: Exercise: Populate the GameViewModel
- Concept 13: The Benefits of a Good Architecture
- Concept 14: The Power and Limits of the ViewModel
- Concept 15: LiveData
- Concept 16: Exercise: Add LiveData to GameViewModel
- Concept 17: Lifecycle Awareness
- Concept 18: Exercise: Add LiveData Encapsulation to GameViewModel
- Concept 19: Event vs. State
- Concept 20: Exercise: Add End Game Event
- Concept 21: Google Interview: Yigit Boyar
- Concept 22: Adding a Timer
- Concept 23: Exercise: Add CountDownTimer
- Concept 24: Exercise: Add a ViewModelFactory
- Concept 25: Exercise: Add ViewModel to Data Binding
- Concept 26: Exercise: Add LiveData Data Binding
- Concept 27: Exercise: LiveData Map Transformation
- Concept 28: Quiz
- Concept 29: Optional Exercise: Adding the Buzzer
- Concept 30: Recap of Architecture and Lifecycles
-
Lesson 06: Building an Android App
In this project, you will build your first Android application with Kotlin! You will build a multi-screened Android application and implement a navigation file to take the user through the app.
-
Part 03 : Developing Android Apps with Kotlin -Part 2
-
Module 01: Developing Android Apps with Kotlin -Part 2
-
Lesson 01: App Architecture (Persistence)
This lesson is all about data persistence, there are many ways to storing data permanently, but with Room things have become even easier than ever before!
- Concept 01: Wake Up, Aleks!
- Concept 02: Looking Forward
- Concept 03: Introduction
- Concept 04: SQLite Primer
- Concept 05: Quiz: SQL
- Concept 06: Designing Entities
- Concept 07: Exercise: Creating the SleepNight Entity
- Concept 08: Data Access Object (DAO)
- Concept 09: Exercise: DAO - SleepDatabaseDao
- Concept 10: Quiz: Select
- Concept 11: Creating a Room Database
- Concept 12: Exercise: Creating a Room Database
- Concept 13: Testing the Room Database
- Concept 14: Displaying Sleep Data
- Concept 15: Adding A ViewModel
- Concept 16: Exercise: Adding a ViewModel
- Concept 17: Multithreading and Coroutines
- Concept 18: Quiz: Room
- Concept 19: Exercise: Coroutines for Long-running Operations
- Concept 20: Googler Interview: Florina Muntenescu
- Concept 21: Navigation and Sleep Quality
- Concept 22: Exercise: Recording Sleep Quality
- Concept 23: Transformation Maps
- Concept 24: Exercise: Button States and SnackBar
- Concept 25: Where to go next?
-
Lesson 02: RecyclerView
Everything is better in a list! Recycler View has been - and continues to be - an essential component of any app design. This lesson is all about making your app better with Recycler Views.
- Concept 01: Recycle Woman
- Concept 02: Looking Forward
- Concept 03: Introduction
- Concept 04: Your first RecyclerView
- Concept 05: Exercise: Add a RecyclerView
- Concept 06: Exercise: Display SleepQuality Data
- Concept 07: Exercise: Recycling ViewHolders
- Concept 08: Displaying Sleep Quality
- Concept 09: Exercise: Display the SleepQuality List
- Concept 10: Exercise: Refactor onBindViewHolder
- Concept 11: Exercise: Refactor onCreateViewHolder
- Concept 12: Improving Data Refresh
- Concept 13: Exercise: Refresh Data with DiffUtil
- Concept 14: Exercise: Add DataBinding to the Adapter
- Concept 15: Exercise: Add Binding Adapters
- Concept 16: Finishing Your First RecyclerView
- Concept 17: Quiz
- Concept 18: Googler Interview: Romain Guy and Chet Haase
- Concept 19: Using GridLayout
- Concept 20: Exercise: Change LinearLayout to GridLayout
- Concept 21: Interacting with List Items
- Concept 22: Exercise: Implement a Click Listener
- Concept 23: Exercise: Navigate on Click
- Concept 24: Adding Headers to the RecyclerView
- Concept 25: Extra Credit: Add a List Header
- Concept 26: Headers in GridLayout
- Concept 27: Extra Credit: Add a Header to the GridLayout
- Concept 28: Summary
-
Lesson 03: Connect to the Internet
Need some live data in your app? In this lesson you'll use Retrofit to communicate with any API service out there. You'll also use Glide to display images from the web.
- Concept 01: Greetings Earth Friends!
- Concept 02: Looking Forward
- Concept 03: Introduction
- Concept 04: RESTful Services
- Concept 05: Libraries
- Concept 06: App Walkthrough and Starter Code
- Concept 07: Exercise: Connecting to the Internet
- Concept 08: Permissions
- Concept 09: Exercise: Parsing the JSON Response
- Concept 10: Exercise: Coroutines and Deferred
- Concept 11: Googler Interview: Jake Wharton
- Concept 12: Exercise: Display an Internet Image
- Concept 13: Exercise: Display Images in a Grid
- Concept 14: Exercise: Error Handling with RecyclerView
- Concept 15: Parcel and Parcelables
- Concept 16: Exercise: Add the Detail Screen
- Concept 17: Exercise: Add a Filter
- Concept 18: Quiz
- Concept 19: Summary
-
Lesson 04: Behind the Scenes
Not everything is displayed on the screen. In Android, there's so much happening in the background and you'll get to build your own background services and tasks in this lesson.
- Concept 01: Offline Movie Night
- Concept 02: Looking Forward
- Concept 03: Exercise: Introduction
- Concept 04: What’s in a Cache
- Concept 05: How to store data
- Concept 06: Decorating a Room
- Concept 07: Building a Room
- Concept 08: Exercise: Add a DatabaseVideo Entity
- Concept 09: Exercise: Add the VideoDao
- Concept 10: Exercise: Refactor the VideoDao
- Concept 11: Exercise: Add the VideosDatabase
- Concept 12: Room Review
- Concept 13: Googler Interview: Sumir Kataria
- Concept 14: Using a Room
- Concept 15: Exercise: Build a Repository
- Concept 16: Exercise: Use the Repository
- Concept 17: Video: Offline Caching Review
- Concept 18: WorkManager for the background
- Concept 19: Exercise: Create a Worker
- Concept 20: Exercise: Schedule Background Work
- Concept 21: Wrapping up Caching
- Concept 22: Quiz
-
Lesson 05: Designing for Everyone
Coming up with a good design for an app is always hard, but creating a great design is more than just colors and layouts. Let's build an app that is designed for everyone, everywhere!
- Concept 01: Party Planning
- Concept 02: Looking Forward
- Concept 03: Styling on Android
- Concept 04: Design Through the Looking Glass
- Concept 05: Exercise: Add TextView Attributes
- Concept 06: Themes and Fonts
- Concept 07: Exercise: Apply a Theme
- Concept 08: Exercise: Add Styles to Headers
- Concept 09: How Styling Information is Communicated to a View
- Concept 10: Material Design
- Concept 11: Exercise: Add a Floating Action Button
- Concept 12: Styling in a material world
- Concept 13: Exercise: Add Material Attributes and Overlay
- Concept 14: Consistent Styling
- Concept 15: Exercise: Use Dimens Resources
- Concept 16: Exercise: Add Material Colors
- Concept 17: Designing for everyone
- Concept 18: RTL languages
- Concept 19: Exercise: Add-RTL-Support
- Concept 20: Googler Interview: Victor Tsaran
- Concept 21: Install and Use the Scanner
- Concept 22: Exercise : Add Content Descriptions
- Concept 23: Exercise: Add Content Grouping
- Concept 24: Exercise: Add a Live Region
- Concept 25: Using drawables
- Concept 26: Exercise: Add a ChipGroup
- Concept 27: Introducing Dark Mode
- Concept 28: Exercise: Add Dark Mode Support
- Concept 29: What's next
- Concept 30: Wrapping up Material
- Concept 31: Quiz
-
Lesson 06: Building Features for android app
In this project, you will build an app using a free, open-source API provided by the NASA JPL Asteroid team.
-
Part 04 : Advanced Android Apps with Kotlin - Part 1
-
Module 01: Advanced Android Apps with Kotlin - Part 1
-
Lesson 01: Course Introduction
This lesson introduces you to Advanced Kotlin features.
-
Lesson 02: Using Notifications
In this lesson, you will learn how to use notifications.
- Concept 01: Introduction
- Concept 02: Getting Started
- Concept 03: Exercise: A Basic Notification
- Concept 04: Notification Channels
- Concept 05: Exercise: Notification Channels
- Concept 06: Exercise: Add Notifications to your App
- Concept 07: Using Intents
- Concept 08: Exercise: Add a Content Intent
- Concept 09: Update and Cancel Notifications
- Concept 10: Exercise: Cancel the Notification
- Concept 11: Customizing Notifications
- Concept 12: Exercise: Style your Notification
- Concept 13: Actions
- Concept 14: Exercise: Add Snooze Action
- Concept 15: Notification Importance
- Concept 16: Exercise: Importance
- Concept 17: Exercise: Notification Badges
- Concept 18: Push Notifications and FCM
- Concept 19: Exercise: Add Firebase to your Project
- Concept 20: Sending FCM Notifications
- Concept 21: Exercise: Single Device Notifications
- Concept 22: Exercise: Topic Notifications
- Concept 23: Data Messages
- Concept 24: Exercise: Data Messages
- Concept 25: Exercise: Foreground vs. Background
- Concept 26: Quiz
- Concept 27: Wrap up
-
Lesson 03: Creating Custom Views
In this lesson, you will learn how to create custom views.
- Concept 01: Looking Forward
- Concept 02: Introduction
- Concept 03: App Overview
- Concept 04: Understanding Custom Views
- Concept 05: Exercise: Create Custom View
- Concept 06: Drawing Custom Views
- Concept 07: Exercise: Draw the Fan Controller
- Concept 08: Exercise: Add View Interactivity
- Concept 09: Exercise: Custom Attributes
- Concept 10: Quiz
- Concept 11: Outro
-
Lesson 04: Drawing on Canvas Objects
In this lesson, you will learn how to draw on canvas objects.
- Concept 01: Introduction
- Concept 02: Canvas Operations
- Concept 03: Drawing on a Canvas
- Concept 04: App Overview
- Concept 05: Exercise: Create the MiniPaint Project
- Concept 06: Exercise: Create the MyCanvasView Class
- Concept 07: Exercise: Set MyCanvasView as the Content View
- Concept 08: Exercise: Override onSizeChanged()
- Concept 09: Exercise: Override onDraw()
- Concept 10: Exercise: Set up Paint for Drawing
- Concept 11: Exercise: Initialize a Path Object
- Concept 12: Exercise: Touch Events
- Concept 13: Exercise: Implement touchStart()
- Concept 14: Exercise: Implement touchMove()
- Concept 15: Exercise: Implement touchUp()
- Concept 16: Exercise: Frames
- Concept 17: Exercise: Storage
- Concept 18: Quiz
- Concept 19: Outro
-
Lesson 05: Clipping Canvas Objects
In this lesson, you will learn how to clip canvas objects.
- Concept 01: Introduction
- Concept 02: Clipping
- Concept 03: App Overview
- Concept 04: Exercise: Create the ClippingExample Project
- Concept 05: Exercise: Add Dimensions and String Resources
- Concept 06: Exercise: Create and Initialize a Paint and a Path Object
- Concept 07: Exercise: Set up the shapes
- Concept 08: Exercise: Set Up Row and Column Locations
- Concept 09: The Drawing Algorithm
- Concept 10: Exercise: Override onDraw()
- Concept 11: drawClipped
- Concept 12: Exercise: Create the drawClippedRectangle() Method
- Concept 13: Exercise: Implement drawBackAndUnclippedRectangle()
- Concept 14: Clipping Methods
- Concept 15: Implement drawDifferenceClippingExample
- Concept 16: Implement drawCircularClippingExample
- Concept 17: Implement drawIntersectionClippingExample
- Concept 18: Implement drawCombinedClippingExample
- Concept 19: Implement drawRoundedRectangleClippingExample
- Concept 20: Implement drawOutsideClippingExample
- Concept 21: Implement drawTranslatedTextExample
- Concept 22: Implement drawSkewedTextExample
- Concept 23: quickReject
- Concept 24: Outro
-
Lesson 06: Android Property Animations
In this lesson, you will go deeper into the properties of animations.
-
Lesson 07: Using MotionLayout to Animate Android Apps
In this lesson, you will be using MotionLayout in your animation.
- Concept 01: Introduction
- Concept 02: Intro to Motion Layout
- Concept 03: Getting Started
- Concept 04: Motion Scenes
- Concept 05: Starter Code
- Concept 06: Animations with MotionLayout
- Concept 07: Animating based on drag events
- Concept 08: Modifying a path
- Concept 09: Instructor Check-In
- Concept 10: Building complex paths
- Concept 11: Changing attributes during motion
- Concept 12: Changing custom attributes
- Concept 13: Drag events and complex paths
- Concept 14: Running motion with code
- Concept 15: Where to go next?
- Concept 16: Quiz
-
Lesson 08: Building an Advanced Android app
In this project you will create an Android app that will download a file from the internet, and create notifications, custom views and animations to build a status bar in your app.
Project Description - Design an App with Application Loading Status
Project Rubric - Design an App with Application Loading Status
-
Part 05 : Advanced Android Apps with Kotlin - Part 2
-
Module 01: Advanced Android Apps with Kotlin - Part 2
-
Lesson 01: Wandering in Google maps with Kotlin
Learn how to use maps
- Concept 01: Looking Forward
- Concept 02: Introduction
- Concept 03: Create a Google Maps Project
- Concept 04: Getting an API Key
- Concept 05: Add map types
- Concept 06: Adding Markers
- Concept 07: Adding markers on long click
- Concept 08: Adding markers on POI click
- Concept 09: Style your map
- Concept 10: Styling your marker
- Concept 11: Add an overlay
- Concept 12: Enable Location Tracking
- Concept 13: Final Summary
-
Lesson 02: Virtual Treasure Hunt with Geofences
Learn how to use Geofences and create a virtual treasure hunt app
- Concept 01: Introduction
- Concept 02: Run the Starter Code
- Concept 03: Request Permission
- Concept 04: Check Device Location
- Concept 05: Adding Geofences
- Concept 06: Update Broadcast Receiver
- Concept 07: Removing Geofences
- Concept 08: Navigate to winning location
- Concept 09: Mock Location on Emulator
- Concept 10: Coding Challenge
- Concept 11: Quiz
- Concept 12: Summary
-
Lesson 03: Testing: Basics
Learn the basics of testing.
- Concept 01: Looking Forward
- Concept 02: Welcome to Testing
- Concept 03: Testing Lesson Map
- Concept 04: Code Checkpoint: Download the App
- Concept 05: Default Test Setup
- Concept 06: Run You First Test
- Concept 07: androidTest vs. Test
- Concept 08: Write Your First Test
- Concept 09: Write Your First Test Continued
- Concept 10: Solution: Write Your First Test
- Concept 11: Make Your Tests Readable
- Concept 12: Planning a Testing Strategy
- Concept 13: App Tour
- Concept 14: Setup a ViewModel Test
- Concept 15: AndroidX Test
- Concept 16: LiveData Testing Basics
- Concept 17: Write Your Own ViewModel Test
- Concept 18: Solution: Write Your Own ViewModel Test
- Concept 19: Take A Break!
-
Lesson 04: Testing: Intro to Test Doubles & Dependency Injection
Learn how to use Test Doubles, Dependency Injections, and Espresso to test your app.
- Concept 01: Test Doubles
- Concept 02: Code Checkpoint: Make a FakeDataSource
- Concept 03: Dependency Injection (DI)
- Concept 04: Test Repository with Constructor Dependency Injection and DI
- Concept 05: Where else to use Dependency Injection?
- Concept 06: Set Up a Fake Repository
- Concept 07: Use the Fake Repository inside a ViewModel
- Concept 08: FragmentScenario
- Concept 09: Launch a Fragment from a Test
- Concept 10: Service Locators
- Concept 11: Use a Service Locator
- Concept 12: Use Your Service Locator in your Tests
- Concept 13: Using Espresso to Test a Fragment
- Concept 14: Espresso Write Your Own Test
- Concept 15: Solution: Text Espresso Write Your Own Test
- Concept 16: Introduction to Mocks
- Concept 17: Using Mockito to Write Navigation Tests
- Concept 18: Solution: Write Your Own Integration Test with Navigation
-
Lesson 05: Testing: Survey of Advanced Topics
Learning how to Navigation Testing, Coroutines, Room, Databinding, and End to End Tests.
- Concept 01: Testing Asynchronous Code
- Concept 02: Review of Testing Coroutines
- Concept 03: Code Checkpoint: viewModelScope and TestCoroutineDispatcher
- Concept 04: MainCoroutineRule and Injecting Dispatchers
- Concept 05: StatisticsViewModelTest
- Concept 06: Testing Coroutine Timing
- Concept 07: Testing Error Handling
- Concept 08: Testing Room
- Concept 09: Testing Local Data Source
- Concept 10: Idling Resources and End-to-End Testing
- Concept 11: Counting Idling Resource
- Concept 12: Databinding Idling Resource
- Concept 13: Using Idling Resources
- Concept 14: Code Checkpoint: Testing Global App Navigation
- Concept 15: Testing Lesson Summary
-
Lesson 06: Implementing Login on Android with FirebaseUI
Learn how to implement login for your Android app using the FirebaseUI open-source library.
- Concept 01: Introduction
- Concept 02: Getting Started
- Concept 03: Project Walkthrough
- Concept 04: Enabling Authentication Methods
- Concept 05: Enabling Login
- Concept 06: Updating UI - Introduction
- Concept 07: Updating UI - Code
- Concept 08: Summary & Next Exercises
- Concept 09: Condition Navigation - Introduction
- Concept 10: Enable Settings Button
- Concept 11: Navigation Based on State
- Concept 12: Navigation After Login
- Concept 13: Quiz
- Concept 14: Final Summary
-
Lesson 07: Project: Location Reminder
In this project, you will build a To-do List app that includes Google Maps and location services.
-
Part 06 : Android Capstone Project
-
Module 01: Android Capstone Project
-
Lesson 01: Design and Build an Android Application
In this project, you will have the opportunity to design and build either a custom Android application inspired by your own idea or an example provided to you.
Project Description - Design and Build an Android Application
-
Part 07 (Career): Career Services
The Careers team at Udacity is here to help you move forward in your career - whether it's finding a new job, exploring a new career path, or applying new skills to your current job.
-
Module 01: Career Services
-
Lesson 01: Take 30 Min to Improve your LinkedIn
Find your next job or connect with industry peers on LinkedIn. Ensure your profile attracts relevant leads that will grow your professional network.
- Concept 01: Get Opportunities with LinkedIn
- Concept 02: Use Your Story to Stand Out
- Concept 03: Why Use an Elevator Pitch
- Concept 04: Create Your Elevator Pitch
- Concept 05: Use Your Elevator Pitch on LinkedIn
- Concept 06: Create Your Profile With SEO In Mind
- Concept 07: Profile Essentials
- Concept 08: Work Experiences & Accomplishments
- Concept 09: Build and Strengthen Your Network
- Concept 10: Reaching Out on LinkedIn
- Concept 11: Boost Your Visibility
- Concept 12: Up Next
-
Lesson 02: Optimize Your GitHub Profile
Other professionals are collaborating on GitHub and growing their network. Submit your profile to ensure your profile is on par with leaders in your field.
- Concept 01: Prove Your Skills With GitHub
- Concept 02: Introduction
- Concept 03: GitHub profile important items
- Concept 04: Good GitHub repository
- Concept 05: Interview with Art - Part 1
- Concept 06: Identify fixes for example “bad” profile
- Concept 07: Quick Fixes #1
- Concept 08: Quick Fixes #2
- Concept 09: Writing READMEs with Walter
- Concept 10: Interview with Art - Part 2
- Concept 11: Commit messages best practices
- Concept 12: Reflect on your commit messages
- Concept 13: Participating in open source projects
- Concept 14: Interview with Art - Part 3
- Concept 15: Participating in open source projects 2
- Concept 16: Starring interesting repositories
- Concept 17: Next Steps
-