Udemy - Progressive Web Apps (PWA) - The Complete Guide

Category: Tutorial


Posted on 2019-10-05, by phaelx.

Description



Date: May 2019
Author: Academind by Maximilian Schwarzmüller

Size: 1.6 GB
Format: MP4
Download     >>    https://earn4files.com/q7ajccx0uh7n
What you'll learn
   *Build web apps that look and feel like native mobile apps for iOS and Android
   *Use service workers to build web apps that work without internet connection (offline-first)
   *Leverage device features like the camera and geolocation in your web apps
   *Use web push notifications to increase user engagement with your web apps


Course content

Getting Started
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course

Understanding the App Manifest
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links

The Service Workers
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links

Promise and Fetch
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links

Service Workers - Caching
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links

Service Workers - Advanced Caching
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links

IndexedDB and Dynamic Data
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links

Creating a Responsive User Interface (UI)
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links

Background Sync
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links

Web Push Notifications
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why we need Web Push Notifications
   How Push & Notifications Work
   Displaying Notifications - Some Theory First
   Browser Support
   Requesting Permissions
   Displaying Notifications
   Notifications from Within the Service Worker
   Understanding Notifications' Options
   Advanced Options
   Adding Actions to Notifications
   Reacting to Notification Interaction - Clicks
   Reacting to Notification Interaction - Closing
   From Notifications to Push Messages
   Creating a Push Subscription
   Storing Subscriptions
   Connecting Server & Client (PWA)
   Sending Push Messages from the Server
   Listening to Push Messages
   Displaying Push Notifications on a Real Device
   Opening a Page upon User Interaction
   Improving our Code
   Wrap Up
   Useful Resources & Links

Native Device Features
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why we need Web Push Notifications
   How Push & Notifications Work
   Displaying Notifications - Some Theory First
   Browser Support
   Requesting Permissions
   Displaying Notifications
   Notifications from Within the Service Worker
   Understanding Notifications' Options
   Advanced Options
   Adding Actions to Notifications
   Reacting to Notification Interaction - Clicks
   Reacting to Notification Interaction - Closing
   From Notifications to Push Messages
   Creating a Push Subscription
   Storing Subscriptions
   Connecting Server & Client (PWA)
   Sending Push Messages from the Server
   Listening to Push Messages
   Displaying Push Notifications on a Real Device
   Opening a Page upon User Interaction
   Improving our Code
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Preparing the Project
   Getting DOM Access
   Creating our own Polyfills
   Getting the Video Image
   Hooking Up the Capture Button
   Storing the Image on a Server
   Accepting File Upload Example with Firebase
   MUST READ: Required Changes to Cloud Function Code
   Testing the Camera & Upload
   Implementing a Fallback
   Getting the User Position
   Fixing Bugs
   Testing the App on a Real Device
   Wrap Up
   Useful Resources & Links

Service Worker Management with Workbox
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why we need Web Push Notifications
   How Push & Notifications Work
   Displaying Notifications - Some Theory First
   Browser Support
   Requesting Permissions
   Displaying Notifications
   Notifications from Within the Service Worker
   Understanding Notifications' Options
   Advanced Options
   Adding Actions to Notifications
   Reacting to Notification Interaction - Clicks
   Reacting to Notification Interaction - Closing
   From Notifications to Push Messages
   Creating a Push Subscription
   Storing Subscriptions
   Connecting Server & Client (PWA)
   Sending Push Messages from the Server
   Listening to Push Messages
   Displaying Push Notifications on a Real Device
   Opening a Page upon User Interaction
   Improving our Code
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Preparing the Project
   Getting DOM Access
   Creating our own Polyfills
   Getting the Video Image
   Hooking Up the Capture Button
   Storing the Image on a Server
   Accepting File Upload Example with Firebase
   MUST READ: Required Changes to Cloud Function Code
   Testing the Camera & Upload
   Implementing a Fallback
   Getting the User Position
   Fixing Bugs
   Testing the App on a Real Device
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Workbox 3.x vs 2.x
   Installing Workbox & Using It
   Configuring Workbox Precaching
   Customizing the Service Worker
   Implementing Routing with the Workbox Router
   Expanding Dynamic Caching
   Options and Setting Up Strategies
   Custom Handlers (Example: For IndexedDB)
   Providing an Offline HTML Fallback
   Handling Background Synchronisation and Push Notifications
   Understanding the Workbox Documentation
   Enhancing the Build Workflow
   Running our App on a Real Server
   Auditing our Webpage with Lighthouse
   Wrap Up
   Useful Resources & Links

SPAs and PWAs
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why we need Web Push Notifications
   How Push & Notifications Work
   Displaying Notifications - Some Theory First
   Browser Support
   Requesting Permissions
   Displaying Notifications
   Notifications from Within the Service Worker
   Understanding Notifications' Options
   Advanced Options
   Adding Actions to Notifications
   Reacting to Notification Interaction - Clicks
   Reacting to Notification Interaction - Closing
   From Notifications to Push Messages
   Creating a Push Subscription
   Storing Subscriptions
   Connecting Server & Client (PWA)
   Sending Push Messages from the Server
   Listening to Push Messages
   Displaying Push Notifications on a Real Device
   Opening a Page upon User Interaction
   Improving our Code
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Preparing the Project
   Getting DOM Access
   Creating our own Polyfills
   Getting the Video Image
   Hooking Up the Capture Button
   Storing the Image on a Server
   Accepting File Upload Example with Firebase
   MUST READ: Required Changes to Cloud Function Code
   Testing the Camera & Upload
   Implementing a Fallback
   Getting the User Position
   Fixing Bugs
   Testing the App on a Real Device
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Workbox 3.x vs 2.x
   Installing Workbox & Using It
   Configuring Workbox Precaching
   Customizing the Service Worker
   Implementing Routing with the Workbox Router
   Expanding Dynamic Caching
   Options and Setting Up Strategies
   Custom Handlers (Example: For IndexedDB)
   Providing an Offline HTML Fallback
   Handling Background Synchronisation and Push Notifications
   Understanding the Workbox Documentation
   Enhancing the Build Workflow
   Running our App on a Real Server
   Auditing our Webpage with Lighthouse
   Wrap Up
   Useful Resources & Links
   Module Introduction
   React with create-react-app
   A General Note about SPAs and PWAs
   Angular with the CLI
   Vue with Vue CLI
   Wrap Up
   Useful Resources & Links

Course Roundup
   About this Course
   What are Progressive Web Apps?
   PWAs vs Native Mobile Apps
   A Demo PWA & What We'll Build in this Course
   Our First Progressive Web App
   PWA Core Building Blocks
   Comparing PWAs and SPAs
   What is 'Progressive Enhancement'?
   Course Outline
   Course Project Setup
   How to get the Most out of this Course
   Module Introduction
   Using an App Manifest to Make your App Installable
   Adding the Manifest
   Understanding App Manifest Properties
   Adding Properties to the App Manifest
   PWAs and Browser Support
   Using the Chrome Developer Tools
   Simulating the Web App on an Emulator
   Preparing the Emulated Device for ALL PWA Features
   Installing the Web App - Prerequisites
   Understanding manifest.json
   Adding Properties for Safari
   Adding Properties for the Internet Explorer
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Service Workers Are Amazing!
   Understanding Service Worker Events
   The Service Worker Lifecycle
   Service Worker Browser Support
   Registering a Service Worker
   Reacting to Incoming Events (in SW)
   Updating & Activating Service Workers
   Non-Lifecycle Events
   The App Install Banner & Chrome 68+
   Getting that 'App Install Banner'
   Connecting Chrome Developer Tools to a Real/ Emulated Device
   Testing the App on Real Device (and Installing the App!)
   Deferring the App Install Banner
   Wrap Up
   Service Worker FAQ
   Useful Resources & Links
   Module Introduction
   Async Code in JavaScript
   Promises - Basics
   Rejecting Promises
   Where we Use Promises in our Project
   Fetch - Basics
   Sending Post Requests via Fetch
   Fetch and CORS
   Comparing Fetch and Ajax
   Adding Polyfills (for Legacy Browser Support)
   Fetch & Service Workers
   Time to Practice - Promises & Fetch API
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why Caching?
   Understanding the Cache API
   Browser Support
   Adjusting the Course Project
   Identifying (Pre-)Cacheable Items
   Static Caching/ Precaching
   Retrieving Items from the Cache
   Adding & Retrieving Multiple Files (to/ from Cache)
   Cache Multiple Files with addAll
   Dynamic Caching - The Basics
   Implementing Dynamic Caching
   Handling Errors
   Adding Cache Versioning
   Different Cache Versions & Cleanup
   Optimizing Cache Management
   Time to Practice: Service Workers & Caching
   [OPTIONAL] Assignment Solution
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Module Preparation: Adding a Button
   Offering 'Cache on Demand'
   Providing an Offline Fallback Page
   Strategy: Cache with Network Fallback
   Strategy: Cache Only
   Strategy: Network Only
   Strategy: Network with Cache Fallback
   Strategy: Cache then Network
   Cache then Network & Dynamic Caching
   Cache then Network with Offline Support
   Cache Strategies & 'Routing'
   Applying Cache Only
   Time to Practice - Advanced Caching
   [OPTIONAL] Assignment Solution
   A Better Way Of Parsing Static Cache URLs
   Making Route Matching More Precise
   A Better Way Of Serving Fallback Files
   Post Request and Cache API
   Cleaning/ Trimming the Cache
   Getting Rid of a Service Worker
   Preparing the Project for the Next Steps
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Changed Firebase Console Layout
   Setting Up Firebase
   Connecting Frontend to Backend
   Dynamic Caching vs. Caching Dynamic Content
   Introducing IndexedDB
   IndexedDB Browser Support
   Adding the IDB File
   Storing Fetched Posts in IndexedDB
   Using IndexedDB in the Service Worker
   Reading Data from IDB
   Clearing IDB & Handling Server-Client Mismatch
   Implementing the Clear Database Method
   Deleting Single Items from the Database
   IndexedDB and Caching Strategies
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Responsive Design in this Course
   Understanding Responsive Design in our Project
   CSS and Media Queries
   Want to see more of your Images?
   Using Images in a Responsive Way
   Adding Animations
   The Viewport & Scaling
   Wrap Up
   Useful Resources & Links
   Module Introduction
   How does Background Sync Work?
   Adding the Basic Setup to our Project
   Registering a Synchronization Task
   Storing our Post in IndexedDB
   Adding a Fallback
   Syncing Data in the Service Worker
   Understanding Periodic Sync
   Adding Server Side Code
   Fixing Errors
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Why we need Web Push Notifications
   How Push & Notifications Work
   Displaying Notifications - Some Theory First
   Browser Support
   Requesting Permissions
   Displaying Notifications
   Notifications from Within the Service Worker
   Understanding Notifications' Options
   Advanced Options
   Adding Actions to Notifications
   Reacting to Notification Interaction - Clicks
   Reacting to Notification Interaction - Closing
   From Notifications to Push Messages
   Creating a Push Subscription
   Storing Subscriptions
   Connecting Server & Client (PWA)
   Sending Push Messages from the Server
   Listening to Push Messages
   Displaying Push Notifications on a Real Device
   Opening a Page upon User Interaction
   Improving our Code
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Preparing the Project
   Getting DOM Access
   Creating our own Polyfills
   Getting the Video Image
   Hooking Up the Capture Button
   Storing the Image on a Server
   Accepting File Upload Example with Firebase
   MUST READ: Required Changes to Cloud Function Code
   Testing the Camera & Upload
   Implementing a Fallback
   Getting the User Position
   Fixing Bugs
   Testing the App on a Real Device
   Wrap Up
   Useful Resources & Links
   Module Introduction
   Understanding the Basics
   Workbox 3.x vs 2.x
   Installing Workbox & Using It
   Configuring Workbox Precaching
   Customizing the Service Worker
   Implementing Routing with the Workbox Router
   Expanding Dynamic Caching
   Options and Setting Up Strategies
   Custom Handlers (Example: For IndexedDB)
   Providing an Offline HTML Fallback
   Handling Background Synchronisation and Push Notifications
   Understanding the Workbox Documentation
   Enhancing the Build Workflow
   Running our App on a Real Server
   Auditing our Webpage with Lighthouse
   Wrap Up
   Useful Resources & Links
   Module Introduction
   React with create-react-app
   A General Note about SPAs and PWAs
   Angular with the CLI
   Vue with Vue CLI
   Wrap Up
   Useful Resources & Links
   Course Roundup
   Bonus: More Content!


Sponsored High Speed Downloads
6202 dl's @ 3784 KB/s
Download Now [Full Version]
6080 dl's @ 3041 KB/s
Download Link 1 - Fast Download
5010 dl's @ 2864 KB/s
Download Mirror - Direct Download



Search More...
Udemy - Progressive Web Apps (PWA) - The Complete Guide

Search free ebooks in ebookee.com!


Links
Download this book

No active download links here?
Please check the description for download links if any or do a search to find alternative books.


Related Books


Comments

No comments for "Udemy - Progressive Web Apps (PWA) - The Complete Guide".


    Add Your Comments
    1. Download links and password may be in the description section, read description carefully!
    2. Do a search to find mirrors if no download links or dead links.
    Back to Top