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
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!
*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
9753 dl's @ 3797 KB/s
Download Now [Full Version]
7775 dl's @ 2370 KB/s
Download Link 1 - Fast Download
8576 dl's @ 2218 KB/s
Download Mirror - Direct Download
Search More...
Udemy - Progressive Web Apps (PWA) - The Complete GuideLinks
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
- Ebooks list page : 41508
- 2020-04-15Progressive Web Apps (pwa) The Complete Guide (updated 12020)
- 2020-02-24Progressive Web Apps (PWA) - The Complete Guide (Updated 12020)
- 2019-12-12Progressive Web Apps (PWA) The Complete Guide (Updated 5/2019)
- 2019-11-25Progressive Web Apps (PWA) - The Complete Guide (Updated 52019)
- 2018-12-02Packt - Progressive Web Apps (PWA) - The Complete Guide
- 2018-10-12Progressive Web Apps (PWA) - The Complete Guide
- 2018-08-14Progressive Web Apps (PWA) - The Complete Guide
- 2018-07-10Progressive Web Apps (PWA) - The Complete Guide
- 2018-06-15Progressive Web Apps (PWA) - The Complete Guide
- 2012-05-12Panzertruppen Vol.1: The Complete Guide to the Creation & Combat Employment of Germany's Tank Force 1933-1942
- 2020-10-13Progressive Web Apps (pwa) From Beginner To Expert
- 2020-09-21Angular Progressive Web Apps (PWA) MasterClass
- 2020-09-20Angular Progressive Web Apps (PWA) MasterClass
- 2019-07-13Udemy Testing Ruby With Rspec The Complete Guide
- 2019-02-24Udemy - Testing Ruby with RSpec The Complete Guide
- 2019-02-19Udemy - Testing Ruby with RSpec The Complete Guide
- 2019-02-19Udemy: Testing Ruby with RSpec: The Complete Guide
- 2019-02-18Udemy - Testing Ruby with RSpec The Complete Guide
- 2018-11-16Angular Progressive Web Apps (PWA) MasterClass & FREE E-Book
Comments
No comments for "Udemy - Progressive Web Apps (PWA) - The Complete Guide".
Add Your Comments
- Download links and password may be in the description section, read description carefully!
- Do a search to find mirrors if no download links or dead links.