Slides that were presented during the webrtc Qt Cmake tutorial at IIT-RTC in October 2017 in Chicago. The slides are not yet complete, and will be updated later.
Swarm in a nutshell
• Exposes several Docker Engines as a single virtual Engine
• Serves the standard Docker API
• Extremely easy to get started
• Batteries included but swappable
Being Functional on Reactive Streams with Spring ReactorMax Huang
The journey begins with using Java 8 introduced Optional/Stream/CompletableFuture more functional, after which Reactive Streams is introduced with a homemade implementation that is ultimately made functional to increase usability. Finally Spring Reactor (Project Reactor) is presented and used for building a device simulator periodically reporting data to device controller.
Gaetano Borgione's presentation from the 2017 Open Networking Summit.
Networking is vital for cloud-native apps where distributed computing and development models require speed, simplicity, and scale for massive number of ephemeral containers. Two of the most prevalent container networking models are CNI and CNM for developers using Docker, Mesos, or Kubernetes. This session will present an overview of distributed development, how CNI and CNM models work, and how container frameworks use these models for networking. Gaetano will also discuss the additional functions users need to consider in the control plane and data plane to achieve operational scale and efficiency.
Qt Application Programming with C++ is one of the best Qt QML training and courses in Bangalore India. This workshop is ideal for anyone who want to get started with developing GUI Application using Qt framework. Starting with basics, this workshop covers developing multi-threaded, multimedia and 2D graphics based applications with multiple Do-It-Yourself (DIY) exercises.
My cloud native security talk I gave at Innotech Austin 2018. I cover container and Kubernetes security topics, security features in Kubernetes, including opensource projects you will want to consider while building and maintaining cloud native applications.
Swarm in a nutshell
• Exposes several Docker Engines as a single virtual Engine
• Serves the standard Docker API
• Extremely easy to get started
• Batteries included but swappable
Being Functional on Reactive Streams with Spring ReactorMax Huang
The journey begins with using Java 8 introduced Optional/Stream/CompletableFuture more functional, after which Reactive Streams is introduced with a homemade implementation that is ultimately made functional to increase usability. Finally Spring Reactor (Project Reactor) is presented and used for building a device simulator periodically reporting data to device controller.
Gaetano Borgione's presentation from the 2017 Open Networking Summit.
Networking is vital for cloud-native apps where distributed computing and development models require speed, simplicity, and scale for massive number of ephemeral containers. Two of the most prevalent container networking models are CNI and CNM for developers using Docker, Mesos, or Kubernetes. This session will present an overview of distributed development, how CNI and CNM models work, and how container frameworks use these models for networking. Gaetano will also discuss the additional functions users need to consider in the control plane and data plane to achieve operational scale and efficiency.
Qt Application Programming with C++ is one of the best Qt QML training and courses in Bangalore India. This workshop is ideal for anyone who want to get started with developing GUI Application using Qt framework. Starting with basics, this workshop covers developing multi-threaded, multimedia and 2D graphics based applications with multiple Do-It-Yourself (DIY) exercises.
My cloud native security talk I gave at Innotech Austin 2018. I cover container and Kubernetes security topics, security features in Kubernetes, including opensource projects you will want to consider while building and maintaining cloud native applications.
Introduction to Docker Networking options. We give in-depth description of the different options with single host examples. See our other presentations for multi-host, IPv6, and CoreOS Flannel descriptions.
The features released between Java 11 and Java 17 have brought a greater opportunity for developers to improve application development productivity as well and code expressiveness and readability. In this deep-dive session, you will discover all the recent Project Amber features added to the Java language such as Records (including Records serialization), Pattern Matching for `instanceof`, switch expression, sealed classes, and hidden classes. The main goal of the Amber Project is to bring Pattern Matching to the Java platform, which will impact both the language and the JDK APsI. You will discover record patterns, array patterns, as well as deconstruction patterns, through constructors, factory methods, and deconstructors.
You can find the code shown here: https://github.com/JosePaumard/devoxx-uk-2021
KubeVirt (Kubernetes and Cloud Native Toronto)Stephen Gordon
In this session Stephen will present the use cases for and current state of the KubeVirt project (http://www.kubevirt.io/), which aims to build a virtualization API for Kubernetes in order to manage virtual machines which themselves run in Kubernetes pods.
You will also hear how this project differs from, and is complementary to, the recently announced Katacontainers (https://katacontainers.io/) project.
The Docker network overlay driver relies on several technologies: network namespaces, VXLAN, Netlink and a distributed key-value store. This talk will present each of these mechanisms one by one along with their userland tools and show hands-on how they interact together when setting up an overlay to connect containers.
The talk will continue with a demo showing how to build your own simple overlay using these technologies.
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
Traditional virtualization technologies have been used by cloud infrastructure providers for many years in providing isolated environments for hosting applications. These technologies make use of full-blown operating system images for creating virtual machines (VMs). According to this architecture, each VM needs its own guest operating system to run application processes. More recently, with the introduction of the Docker project, the Linux Container (LXC) virtualization technology became popular and attracted the attention. Unlike VMs, containers do not need a dedicated guest operating system for providing OS-level isolation, rather they can provide the same level of isolation on top of a single operating system instance.
An enterprise application may need to run a server cluster to handle high request volumes. Running an entire server cluster on Docker containers, on a single Docker host could introduce the risk of single point of failure. Google started a project called Kubernetes to solve this problem. Kubernetes provides a cluster of Docker hosts for managing Docker containers in a clustered environment. It provides an API on top of Docker API for managing docker containers on multiple Docker hosts with many more features.
Kubernetes has two simple but powerful network concepts: every Pod is connected to the same network, and Services let you talk to a Pod by name. Bryan will take you through how these concepts are implemented - Pod Networks via the Container Network Interface (CNI), Service Discovery via kube-dns and Service virtual IPs, then on to how Services are exposed to the rest of the world.
A tutorial on how the process of writing an application using a browser’s WebAuthn API, plus how to install a server, how to generate authentication challenges & responses, and how to integrate with related IAM infrastructure.
Code: https://github.com/fido-alliance/webauthn-demo
Live slides: http://slides.com/herrjemand/jan-2018-fido-seminar-webauthn-tutorial#/
Introduction to the Container Network Interface (CNI)Weaveworks
CNI, the Container Network Interface, is a standard API between container runtimes and container network implementations. These slides are from the Cloud Native Computing Foundation's Webinar, and explain what CNI is, how you use it, and what lies ahead on the roadmap.
Building CI/CD Pipelines with Jenkins and KubernetesJanakiram MSV
Learn how to configure CI/CD pipelines with Jenkins and Kubernetes. We will show you to how to automate deployments from source code to production clusters.
Code on the Beach 2019 - Let's Take a Tour of .Net Core: CLIBrian McKeiver
The .NET Core command-line interface (CLI) allows developers to easily automate and script many tasks in the .NET world. From create new projects in seconds, to automating builds, to setting up better CI with automated testing, and making working with containers possible, this new CLI can almost do it all (especially if you are coming from the full framework world). Join my session to see the .NET Core CLI in action and put it through its paces. This really is a must have tool for any .NET Core developer out there.
Webinar: Building Embedded Applications from QtCreator with DockerBurkhard Stubert
I show how QtCreator builds an embedded application against a Qt SDK encapsulated in a Docker container. QtCreator doesn't know which Yocto version was used for building the Qt SDK and which environment variables must be set for the SDK. QtCreator forwards the CMake calls for configuring, building and staging the application to the container, which executes these calls in the right environment.
Introduction to Docker Networking options. We give in-depth description of the different options with single host examples. See our other presentations for multi-host, IPv6, and CoreOS Flannel descriptions.
The features released between Java 11 and Java 17 have brought a greater opportunity for developers to improve application development productivity as well and code expressiveness and readability. In this deep-dive session, you will discover all the recent Project Amber features added to the Java language such as Records (including Records serialization), Pattern Matching for `instanceof`, switch expression, sealed classes, and hidden classes. The main goal of the Amber Project is to bring Pattern Matching to the Java platform, which will impact both the language and the JDK APsI. You will discover record patterns, array patterns, as well as deconstruction patterns, through constructors, factory methods, and deconstructors.
You can find the code shown here: https://github.com/JosePaumard/devoxx-uk-2021
KubeVirt (Kubernetes and Cloud Native Toronto)Stephen Gordon
In this session Stephen will present the use cases for and current state of the KubeVirt project (http://www.kubevirt.io/), which aims to build a virtualization API for Kubernetes in order to manage virtual machines which themselves run in Kubernetes pods.
You will also hear how this project differs from, and is complementary to, the recently announced Katacontainers (https://katacontainers.io/) project.
The Docker network overlay driver relies on several technologies: network namespaces, VXLAN, Netlink and a distributed key-value store. This talk will present each of these mechanisms one by one along with their userland tools and show hands-on how they interact together when setting up an overlay to connect containers.
The talk will continue with a demo showing how to build your own simple overlay using these technologies.
Docker Kubernetes Istio
Understanding Docker and creating containers.
Container Orchestration based on Kubernetes
Blue Green Deployment, AB Testing, Canary Deployment, Traffic Rules based on Istio
Traditional virtualization technologies have been used by cloud infrastructure providers for many years in providing isolated environments for hosting applications. These technologies make use of full-blown operating system images for creating virtual machines (VMs). According to this architecture, each VM needs its own guest operating system to run application processes. More recently, with the introduction of the Docker project, the Linux Container (LXC) virtualization technology became popular and attracted the attention. Unlike VMs, containers do not need a dedicated guest operating system for providing OS-level isolation, rather they can provide the same level of isolation on top of a single operating system instance.
An enterprise application may need to run a server cluster to handle high request volumes. Running an entire server cluster on Docker containers, on a single Docker host could introduce the risk of single point of failure. Google started a project called Kubernetes to solve this problem. Kubernetes provides a cluster of Docker hosts for managing Docker containers in a clustered environment. It provides an API on top of Docker API for managing docker containers on multiple Docker hosts with many more features.
Kubernetes has two simple but powerful network concepts: every Pod is connected to the same network, and Services let you talk to a Pod by name. Bryan will take you through how these concepts are implemented - Pod Networks via the Container Network Interface (CNI), Service Discovery via kube-dns and Service virtual IPs, then on to how Services are exposed to the rest of the world.
A tutorial on how the process of writing an application using a browser’s WebAuthn API, plus how to install a server, how to generate authentication challenges & responses, and how to integrate with related IAM infrastructure.
Code: https://github.com/fido-alliance/webauthn-demo
Live slides: http://slides.com/herrjemand/jan-2018-fido-seminar-webauthn-tutorial#/
Introduction to the Container Network Interface (CNI)Weaveworks
CNI, the Container Network Interface, is a standard API between container runtimes and container network implementations. These slides are from the Cloud Native Computing Foundation's Webinar, and explain what CNI is, how you use it, and what lies ahead on the roadmap.
Building CI/CD Pipelines with Jenkins and KubernetesJanakiram MSV
Learn how to configure CI/CD pipelines with Jenkins and Kubernetes. We will show you to how to automate deployments from source code to production clusters.
Code on the Beach 2019 - Let's Take a Tour of .Net Core: CLIBrian McKeiver
The .NET Core command-line interface (CLI) allows developers to easily automate and script many tasks in the .NET world. From create new projects in seconds, to automating builds, to setting up better CI with automated testing, and making working with containers possible, this new CLI can almost do it all (especially if you are coming from the full framework world). Join my session to see the .NET Core CLI in action and put it through its paces. This really is a must have tool for any .NET Core developer out there.
Webinar: Building Embedded Applications from QtCreator with DockerBurkhard Stubert
I show how QtCreator builds an embedded application against a Qt SDK encapsulated in a Docker container. QtCreator doesn't know which Yocto version was used for building the Qt SDK and which environment variables must be set for the SDK. QtCreator forwards the CMake calls for configuring, building and staging the application to the container, which executes these calls in the right environment.
Build and run embedded apps faster from qt creator with dockerQt
Have you ever considered, what it would require to use containers to build and deploy applications to embedded targets?
Of course, you have! So, in this webinar, Burkhard Stubert will show you how to replace cross-building your application in a Docker container, stopping the application on the target system, copying the application from your PC to the target system, and starting the application on the target system with… just clicking a button.
Speakers:
- Burkhard Stubert, Solopreneur, Embedded Use
- Tino Pyssysalo, Senior Product Manager, The Qt Company
These are the slides for a talk/workshop delivered to the Cloud Native Wales user group (@CloudNativeWal) on 2019-01-10.
In these slides, we go over some principles of gitops and a hands on session to apply these to manage a microservice.
You can find out more about GitOps online https://www.weave.works/technologies/gitops/
Are you a QMake user who has not yet familiarized yourself with CMake? If so, this webinar is for you — it’s aimed at anyone using QMake who wants to learn more about CMake and the pros and cons of each. We will:
Provide an introduction to CMake
Discuss the differences in the two build systems and the benefits of using one over the other
Set up a basic project and review some of the potential issues you may run into when starting your new project in CMake or converting from existing QMake projects
Modern Release Engineering in a Nutshell - Why Researchers should Care!Bram Adams
Invited talk at the Leaders of Tomorrow Symposium of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016).
The presentation (and its accompanying paper, see http://mcis.polymtl.ca/publications/2016/fose.pdf) explain the basics of release engineering pipelines, common challenges industry is facing as well as pitfalls software engineering researchers are falling into.
Speakers are Bram Adams (MCIS, http://mcis.polymtl.ca) and Shane McIntosh (McGill University, http://shanemcintosh.org).
A video-taped version of the talk will be available soon at https://www.youtube.com/channel/UCL8yG6qpHk7V66l1Jt3aZrA/featured.
Everybody is consuming NuGet packages these days. It’s easy, right? But how can we create and share our own packages? What is .NET Standard? How should we version, create, publish and share our package?
Once we have those things covered, we’ll look beyond what everyone is doing. How can we use the NuGet client API to fetch data from NuGet? Can we build an application plugin system based on NuGet? What hidden gems are there in the NuGet server API? Can we create a full copy of NuGet.org?
Good questions! In this talk, we will get them answered.
Wouldn't it be great for a new developer on your team to have their dev environment totally set up on their first day? What about having your CI tests running in the background while you work on new features? What about having the confidence that your dev environment mirrors testing and prod? Containers enable this to become reality, along with other great benefits like keeping dependencies nice and tidy and making packaged code easier to share. Come learn about the ways containers can help you build and ship software easily.
Git, CMake, Conan - How to ship and reuse our C++ projects?Mateusz Pusz
These are the slides from my CppCon 2018 talk. You can find the recording here: https://www.youtube.com/watch?v=S4QSKLXdTtA. All my other talks can be found here: https://train-it.eu/resources.
---
Git and CMake are already established standards in our community. However, it is uncommon to see them being used in an efficient way. As a result, many C++ projects have big problems with either importing other dependencies or making themselves easy to import by others. It gets even worse when we need to build many different configurations of our package on one machine.
That presentation lists and addresses the problems of build system and packaging that we have with large, multi-platform, C++ projects that often have many external and internal dependencies. The talk will present how proper use of CMake and Conan package manager can address those use cases. It will also describe current issues with the cooperation of those tools.
If you've attended or seen my talk at C++Now 2018, that time you can expect much more information on Conan and package creation using that tool. I will also describe how the integration of CMake and Conan changed over the last few months.
Real-World Docker: 10 Things We've Learned RightScale
Docker has taken the world of software by storm, offering the promise of a portable way to build and ship software - including software running in the cloud. The RightScale development team has been diving into Docker for several projects, and we'll share our lessons learned on using Docker for our cloud-based applications.
This presents the Grid Manager and Network Instrumentation service on top of KITE, which allow to test any communication system with total programmatically control over the network. Test the behaviour of your (or your competitor's) communication system or more specifically the bandwidth estimation, congestion control, adaptation, .......
Update on WebRTC standard and Implementation Status. Presented at Sydney's webrtc meet-up on may 25 2017. Find the companion blog post at webrtcbydralex.com
This describe the limitation of usual single page, single browser, single OS approach, illustrate current IMTC sponsored effort to improve interoperability testing, and describe a roadmap to improve the quality of app testing.
WebRTC has been an exciting technology, and extremely fast moving for the past years. While its adoption and its disruptive power are not challenged anymore, the fast evolution pace, and the fast update cycles of the browsers made it difficult to build complex solutions on top of it which would leverage all that webrtc has to offer. Late 2015, the different standard committees and corresponding working groups that compose webRTC have finally reach a consensus, and from the convergence of all their efforts, stable specifications were born.
Through the use of GoToMeeting and other software, we will illustrate first the usual pains that most using webrtc have experienced, and then show how the webrtc APIs, which had started as a peer-to-peer API, were extended with an object model API to provide more options and more controls to this who need it, while keeping the simplicity of P2P for the others. The similitudes between the new Object Model API, and the ORTC API (implemented in edge) will also be illustrated.
This document illustrates the use of RTP Transceiver in webRTC model API. It also illustrates the different class pipeline depending on the usage of different transport optimizations. This is the simplified version without the SDP or multiparty/simulcast examples.
Evolution of WebRTC APIs and feature from peer-to-peer to object model in 2015. Include latest updates from November meetings in Japan. Beta, non-complete version. Contact agouaillard@gmail.com for more.
Saudi Arabia stands as a titan in the global energy landscape, renowned for its abundant oil and gas resources. It's the largest exporter of petroleum and holds some of the world's most significant reserves. Let's delve into the top 10 oil and gas projects shaping Saudi Arabia's energy future in 2024.
CFD Simulation of By-pass Flow in a HRSG module by R&R Consult.pptxR&R Consult
CFD analysis is incredibly effective at solving mysteries and improving the performance of complex systems!
Here's a great example: At a large natural gas-fired power plant, where they use waste heat to generate steam and energy, they were puzzled that their boiler wasn't producing as much steam as expected.
R&R and Tetra Engineering Group Inc. were asked to solve the issue with reduced steam production.
An inspection had shown that a significant amount of hot flue gas was bypassing the boiler tubes, where the heat was supposed to be transferred.
R&R Consult conducted a CFD analysis, which revealed that 6.3% of the flue gas was bypassing the boiler tubes without transferring heat. The analysis also showed that the flue gas was instead being directed along the sides of the boiler and between the modules that were supposed to capture the heat. This was the cause of the reduced performance.
Based on our results, Tetra Engineering installed covering plates to reduce the bypass flow. This improved the boiler's performance and increased electricity production.
It is always satisfying when we can help solve complex challenges like this. Do your systems also need a check-up or optimization? Give us a call!
Work done in cooperation with James Malloy and David Moelling from Tetra Engineering.
More examples of our work https://www.r-r-consult.dk/en/cases-en/
Water scarcity is the lack of fresh water resources to meet the standard water demand. There are two type of water scarcity. One is physical. The other is economic water scarcity.
Final project report on grocery store management system..pdfKamal Acharya
In today’s fast-changing business environment, it’s extremely important to be able to respond to client needs in the most effective and timely manner. If your customers wish to see your business online and have instant access to your products or services.
Online Grocery Store is an e-commerce website, which retails various grocery products. This project allows viewing various products available enables registered users to purchase desired products instantly using Paytm, UPI payment processor (Instant Pay) and also can place order by using Cash on Delivery (Pay Later) option. This project provides an easy access to Administrators and Managers to view orders placed using Pay Later and Instant Pay options.
In order to develop an e-commerce website, a number of Technologies must be studied and understood. These include multi-tiered architecture, server and client-side scripting techniques, implementation technologies, programming language (such as PHP, HTML, CSS, JavaScript) and MySQL relational databases. This is a project with the objective to develop a basic website where a consumer is provided with a shopping cart website and also to know about the technologies used to develop such a website.
This document will discuss each of the underlying technologies to create and implement an e- commerce website.
Explore the innovative world of trenchless pipe repair with our comprehensive guide, "The Benefits and Techniques of Trenchless Pipe Repair." This document delves into the modern methods of repairing underground pipes without the need for extensive excavation, highlighting the numerous advantages and the latest techniques used in the industry.
Learn about the cost savings, reduced environmental impact, and minimal disruption associated with trenchless technology. Discover detailed explanations of popular techniques such as pipe bursting, cured-in-place pipe (CIPP) lining, and directional drilling. Understand how these methods can be applied to various types of infrastructure, from residential plumbing to large-scale municipal systems.
Ideal for homeowners, contractors, engineers, and anyone interested in modern plumbing solutions, this guide provides valuable insights into why trenchless pipe repair is becoming the preferred choice for pipe rehabilitation. Stay informed about the latest advancements and best practices in the field.
About
Indigenized remote control interface card suitable for MAFI system CCR equipment. Compatible for IDM8000 CCR. Backplane mounted serial and TCP/Ethernet communication module for CCR remote access. IDM 8000 CCR remote control on serial and TCP protocol.
• Remote control: Parallel or serial interface.
• Compatible with MAFI CCR system.
• Compatible with IDM8000 CCR.
• Compatible with Backplane mount serial communication.
• Compatible with commercial and Defence aviation CCR system.
• Remote control system for accessing CCR and allied system over serial or TCP.
• Indigenized local Support/presence in India.
• Easy in configuration using DIP switches.
Technical Specifications
Indigenized remote control interface card suitable for MAFI system CCR equipment. Compatible for IDM8000 CCR. Backplane mounted serial and TCP/Ethernet communication module for CCR remote access. IDM 8000 CCR remote control on serial and TCP protocol.
Key Features
Indigenized remote control interface card suitable for MAFI system CCR equipment. Compatible for IDM8000 CCR. Backplane mounted serial and TCP/Ethernet communication module for CCR remote access. IDM 8000 CCR remote control on serial and TCP protocol.
• Remote control: Parallel or serial interface
• Compatible with MAFI CCR system
• Copatiable with IDM8000 CCR
• Compatible with Backplane mount serial communication.
• Compatible with commercial and Defence aviation CCR system.
• Remote control system for accessing CCR and allied system over serial or TCP.
• Indigenized local Support/presence in India.
Application
• Remote control: Parallel or serial interface.
• Compatible with MAFI CCR system.
• Compatible with IDM8000 CCR.
• Compatible with Backplane mount serial communication.
• Compatible with commercial and Defence aviation CCR system.
• Remote control system for accessing CCR and allied system over serial or TCP.
• Indigenized local Support/presence in India.
• Easy in configuration using DIP switches.
2. Introduction and goal
Half of the communication applications nowadays, are not web applications. Native
apps, whether mobile, desktop or IoT represent more than 50% of the usage of
communication.
WebRTC is today the best technology to implement a communication app, and has
the sweet~~ advantage of being on-the-wire compatible with the browsers.
Facebook, Whatsapp, viber, … all use a variation of the webrtc code internally.
However many think WebRTC Native is just too hard!
This tutorial is here to demystify webrtc code and show how, given the right tools
and the right approach, you can write your own communication app, scratch that,
communication system, in 4 hours.
2
3. Introduction and goal
Build a native app C++ app that can connect to janus, a webrtc
media server and display a remote stream.
The app and janus, together, provide an entire client / server
system, that can scale down to be run entirely on IoT chips
raspberry pie 3, as well as scale up to millions of users if need be.
The GUI framework chosen, QT, not only is pure C++, can run
unchanged on all desktop Operating systems (MacOsX, Windows,
Linux, …), but is also widely used in embedded applications, and
can run on any kind of ARM, or IoT chips.
3
4. Introduction and goal
To make it achievable in 4 hours, we will provide you
with some components:
- A libwebrtc installer that will provide webrtc
libraries, headers, and other variables, ready to
use.
- A pre-configured, hosted janus instance with the
“video-room” plugin, to connect to.
- A continuous stream is available from the server
4
5. Compiling and using WebRTC … Don’t do it yourself
Mastering Google tools
requires time and patience:
Depots_tools, GN, Ninja
Compilers are differents on
each platform: CL,
MSBUILD, GCC, CLang,
LLVM… As well as linkers.
Compiling is hell: time
consumption, flags and
definitions are hidden and
the layout is changing
frequently.
Keep the code up-to-date
through the versions:
macros are changing,
folders are renamed,
methods deleted... and
maintain a backward
compatibility with older
versions of libwebrtc, every
6 weeks.
Customizing the code is
not simple and test
infrastructures are not
provided by Google.
5
6. Compiling and using WebRTC … Don’t do it yourself
Mastering Google tools
requires time and patience:
Depots_tools, GN, Ninja
Compilers are differents on
each platform: CL,
MSBUILD, GCC, CLang,
LLVM… As well as linkers.
Compiling is hell: time
consumption, flags and
definitions are hidden and
the layout is changing
frequently.
Keep the code up-to-date
through the versions:
macros are changing,
folders are renamed,
methods deleted... and
maintain a backward
compatibility with older
versions of libwebrtc, every
6 weeks.
Customizing the code is
not simple and test
infrastructures are not
provided by Google.
6
WebRTC is not designed to be used as a library
7. Summary
➔ CMake : the basics
◆ First app
7
➔ Qt5 QML module
◆ Hello World
◆ QML Signal Slot
◆ Websocket
◆ Janus API
◆ Debug w Qt Creator
➔ WebRTC
◆ JSEP Overview
◆ Offer impl.
◆ Answer impl.
◆ Trickle ICE impl.
30 mn 45 mn 45 mn 60 mn
➔ Qt5 C++ App
◆ CMake: find_package()
◆ main.cpp file
◆ Link against Qt5 library
◆ Runtime
◆ Signal Slot
8. CMAKE: Let’s get started
8
● Make a project folder
○ This is our source dir
mkdir CMakeTutorial
9. CMAKE: Let’s get started
In a new file CMakeLists.txt :
project( myFirstApp )
9
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
10. CMAKE: Let’s get started
Add in CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( myFirstApp )
10
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
11. CMAKE: Let’s get started
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
● Main.cpp
○ In Source Dir
main.cpp:
#include <iostream>
void main(int argc, char** argv) {
std::cout << “Hello world” << std::endl;
}
11
12. CMAKE: Let’s get started
12
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
● Main.cpp
○ In Source Dir
Edit CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( myFirstApp )
add_executable( myApp main.cpp )
13. CMAKE: Let’s get started
13
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
● Main.cpp
○ In Source Dir
● CMake is out-of-source build style
New folder to be out-of-source
● mkdir MYBUILD
● cd MYBUILD
14. CMAKE: Let’s get started
14
● Make a project folder
○ This is our source dir
● CMakeLists.txt is the main file
○ In Source Dir
● Main.cpp
○ In Source Dir
● CMake is out-of-source build style
○ CMake commands in Build Dir
1. Configure the project
cmake ..
2. Compile with cross-platform command
cmake --build .
3. Run the project and make sure everything works fine.
15. CMAKE: Wrap-Up
CMake
● CMakeLists.txt
● project()
● add_executable()
● CMake configure
● CMake build
● run
I don’t care …. I love it !
Windows / Mac / Linux / …
MSVC / XCode / CLang / ...
15
16. Summary
➔ CMake : the basics
◆ First app
16
➔ Qt5 QML module
◆ Hello World
◆ QML Signal Slot
◆ Websocket
◆ Janus API
◆ Debug w Qt Creator
➔ Qt5 C++ App
◆ CMake: find_package()
◆ main.cpp file
◆ Link against Qt5 library
◆ Runtime
◆ Signal Slot
➔ WebRTC
◆ JSEP Overview
◆ Offer impl.
◆ Answer impl.
◆ Trickle ICE impl.
30 mn 45 mn 45 mn 60 mn
17. Qt5 C++ app: Cmake FindPackage
Create CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( QtFirstApp )
17
● In a new source directory Qt5App
18. Qt5 C++ app: Cmake FindPackage
Add in CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( QtFirstApp )
find_package( Qt5 COMPONENTS Widgets )
18
● In a new source directory Qt5App
● find_package()
19. Qt5 C++ app: Cmake FindPackage: Background
FindXXX.cmake
● One canonical install,
● possibly shipped with CMake,
● old school
xxxConfig.cmake
● Handle multiple installs
○ Which one? Use -D ….
● Shipped with library (always in sync)
● The current way of things
19
● In a new source directory Qt5App
● find_package()
○ FindXXX.cmake
○ XXXConfig.cmake
20. Qt5 C++ app: Cmake FindPackage
CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( myFirstApp )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
find_package( Qt5 COMPONENTS Widgets )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
20
● In a new source directory Qt5App
● find_package()
○ FindXXX.cmake
○ XXXConfig.cmake
● cmake -DQt5_DIR=...
21. Qt5 C++ app: main
main.cpp :
#include <QApplication>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
return app.exec();
}
Create a new file main.cpp in the same
folder as CMakeLists.txt
Since we are using Qt5 GUI, the app will
be running as a QApplication object type.
To run the app, you simply need to call
exec().
21
22. Qt5 C++ app: main
CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0
FATAL_ERROR )
project( myFirstApp )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
find_package( Qt5 COMPONENTS Widgets )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
add_executable( QtFirstApp main.cpp )
22
● In a new source directory Qt5App
● find_package()
○ FindXXX.cmake
○ XXXConfig.cmake
● cmake -DQt5_DIR=...
● Add executable
23. Qt5 C++ app: link to qt libs
At this point, you should have a
compilation error. The linker can not
resolve the QApplication inclusion.
Link the app against Qt library because we
are using Qt5 Widgets module.
Then compile and run the app.
Add to CMakeLists.txt :
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR )
project( myFirstApp )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
find_package( Qt5 COMPONENTS Widgets )
message( STATUS “Qt5 Dir: ${Qt5Core_DIR}.” )
add_executable( QtFirstApp main.cpp )
target_link_libraries( QtFirstApp Qt5::Widgets )
23
24. Qt5 C++ app: WIN: 64 bits and generators
In a Build directory :
Configure with a correct generator to have the app in 64 bits.
cmake -DQt5_DIR=path_to_qt5 -G “Visual Studio 14 2015 Win64” ..
Compile
cmake --build .
24
● In a new source directory Qt5App
● find_package()
○ FindXXX.cmake
○ XXXConfig.cmake
● cmake -DQt5_DIR=...
● Add executable
● cmake -G
○ “Visual Studio 14 2015 <arch>”
■ Win64
○ “NMake Makefiles”
2 ways to use 64 bits environments:
Admin CMD + x64 tools
Admin CMD + vcvarsall.bat
25. Qt5 C++ app: run: WIN: the Qt DLL problem
Windows users :
If you thought it would be that easy to
run a Qt5 app… Wrong!
You will need to copy the missing .dll
from Qt5 folder to the executable folder.
For example, I have 3 errors like this:
25
In C:Qt5.9.2msvc2015_64bin, copy
● Qt5Widgetsd.dll
● Qt5Cored.dll
● Qt5Guid.dll
and paste in the build directory
26. Qt5 C++ app: run: Signal Slot 101
Now, it would be nice to have a button
which can send a message to someone
else.
In general, Qt objects can communicate
with one another by a system called
Signals and Slots.
In main.cpp:
#include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[]){
QApplication app(argc, argv);
QPushButton button("Quit");
button.show();
return app.exec();
}
26
27. Qt5 C++ app: run: Signal Slot 101
A Signal is emitted when a particular
event occurs, like a click.
A Slot is a function that is called in
response to a particular signal.
Let’s connect the button to the app :
When we click on the button, the app will
quit.
In main.cpp:
int main(int argc, char *argv[]){
QApplication app(argc, argv);
QPushButton button("Quit");
QObject::connect(
&button, SIGNAL( clicked() ),
&app, SLOT( quit() )
);
button.show();
return app.exec();
}
27
28. Qt5 C++ app: run: Signal Slot 101
28
1. Compile with cross-platform command
cmake --build .
2. Run the project and make sure everything works fine.
The project should be already
configured, we only need to recompile
the source files.
29. Qt5 C++ app: Wrap-Up
CMake:
cmake -G
cmake -D<VAR>=<VALUE> ..
find_package()
COMPONENTS
REQUIRED
message( STATUS “” )
target_link_library()
Cmake Qt5:
Cmake -DQt5_DIR= ..
target_link_library()
QT5::CORE
Qt5:
Signal
Slot
29
30. Summary
➔ CMake : the basics
◆ First app
30
➔ Qt5 QML module
◆ Hello World
◆ QML Signal Slot
◆ Websocket
◆ Janus API
◆ Debug w Qt Creator
➔ Qt5 C++ App
◆ CMake: find_package()
◆ main.cpp file
◆ Link against Qt5 library
◆ Runtime
◆ Signal Slot
➔ WebRTC
◆ JSEP Overview
◆ Offer impl.
◆ Answer impl.
◆ Trickle ICE impl.
30 mn 45 mn 45 mn 60 mn
31. Qt5 QML app: Hello world
31
Let’s make an app with QML. It is a module
of Qt and allows you to build fluid animated
user interfaces. QML is a JavaScript
compatible scripting language
● In a new source directory QMLTutorial
32. Qt5 QML app: Hello world
main.qml:
import QtQuick 2.0
import QtQuick.Window 2.2
Window {
visible : true
Rectangle {
text {
text: “Hello World”
}
}
}
32
● In a new source directory QMLTutorial
● New file main.qml
33. Qt5 QML app: Hello world
qml.qrc:
<RCC>
<qresource prefix=”/”>
<file>main.qml</file>
</qresource>
</RCC>
33
● In a new source directory QMLTutorial
● New file main.qml
● New file qml.qrc which lists all qml files
34. Qt5 QML app: Hello world
CMakeLists.txt:
cmake_minimum_required( VERSION 3.2.0 FATAL_ERROR)
project( QMLApp )
find_package( Qt5 COMPONENTS Quick Widgets REQUIRED )
set( CMAKE_AUTORCC ON )
add_executable( QMLApp main.cpp qml.qrc )
target_link_libraries( QMLApp Qt5::Widgets Qt5::Quick )
34
● In a new source directory QMLTutorial
● New file main.qml
● New file qml.qrc which lists all qml files
● Add qml.qrc to CMakeLists.txt in
“add_executable()”
● Add set( CMAKE_AUTORCC ON )
35. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
import QtQuick.Controls 1.4
35
Let’s make a button that change the text
“Hello World” when we are clicking on it,
all in QML.
● Import QtQuick.Controls 1.4
36. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
import QtQuick.Controls 1.4
…
Rectangle { … }
Button {
id: myButton
text : "emit signal"
anchors.centerIn: parent
}
36
● Import QtQuick.Controls 1.4
● Add a Button after Rectangle
○ We need an id to identify it
○ And place it in the middle of the
Window with anchors.centerIn
37. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
Button {
id: myButton
text : "emit signal"
anchors.centerIn: parent
signal buttonClicked(string text)
}
37
● Import QtQuick.Controls 1.4
● Add a Button after Rectangle
○ We need an id to identify it
○ And place it in the middle of the
Window with anchors.centerIn
● Add a signal taking a string as an
argument
38. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
Button {
id: myButton
text : "emit signal"
anchors.centerIn: parent
signal buttonClicked(string text)
onClicked: {
myButton.buttonClicked.connect(myText.changeText)
myButton.buttonClicked("Button Clicked")
}
}
38
● Import QtQuick.Controls 1.4
● Add a Button after Rectangle
○ We need an id to identify it
○ And place it in the middle of the
Window with anchors.centerIn
● Add a signal taking a string as an
argument
● Add the behaviors when the button is
Clicked
39. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
Text {
id: myText
text: "Hello World"
}
39
Now the Button is connected, we need to
redefine a bit the Text
● Add an id to Text : myText
40. Qt5 QML app: QML Signal / Slot syntax
Edit main.qml :
Text {
id: myText
text: "Hello World"
function changeText(text) {
myText.text = text
}
}
40
Now the Button is connected, we need to
redefine a bit the Text
● Add an id to Text : myText
● Add a function that change the
attribute text
41. Qt5 QML app: QML Signal / Slot syntax
41
Here you go!
In the build directory:
1. Compile with cross-platform command
cmake --build .
2. Run the project and make sure everything works fine.
48. Summary
➔ CMake : the basics
◆ First app
48
➔ Qt5 QML module
◆ Hello World
◆ QML Signal Slot
◆ Websocket
◆ Janus API
◆ Debug w Qt Creator
➔ Qt5 C++ App
◆ CMake: find_package()
◆ main.cpp file
◆ Link against Qt5 library
◆ Runtime
◆ Signal Slot
➔ WebRTC
◆ JSEP Overview
◆ Offer impl.
◆ Answer impl.
◆ Trickle ICE impl.
30 mn 45 mn 45 mn 60 mn
49. WebRTC installer and CMake
With the libwebrtc installer, you can use
the library quite easily.
With CMake, you only need these :
● find_package()
● target_link_libraries
Let’s try the library!
49
50. WebRTC installer and CMake
First, we need a source file using
libwebrtc function.
● In a new source directory
WebRTCSimpleApp
● Make a new file SimpleApp.cpp
50
In a new main.cpp file :
int main(int argc, char** argv) {
return 0;
}
51. WebRTC installer and CMake
First, we need a source file using
libwebrtc function.
● In a new source directory
WebRTCSimpleApp
● Make a new file SimpleApp.cpp
● Include a header from libwebrtc
51
In a new SimpleApp.cpp file :
#include "webrtc/api/peerconnectioninterface.h"
int main(int argc, char** argv) {
return 0;
}
52. WebRTC installer and CMake
First, we need a source file using
libwebrtc function.
● In a new source directory
WebRTCSimpleApp
● Make a new file SimpleApp.cpp
● Include a header from libwebrtc
● Call functions from the library
52
In a new SimpleApp.cpp file :
#include "webrtc/api/peerconnectioninterface.h"
int main(int argc, char** argv) {
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
peer_connection_factory = webrtc::CreatePeerConnectionFactory();
return 0;
}
53. WebRTC installer and CMake
Now, let’s compile the source file with
CMake.
● Add the cmake_minimum_required
● Add the project
53
In a new CMakeLists.txt :
cmake_minimum_required( VERSION 3.3 )
project( SimpleApp )
54. WebRTC installer and CMake
Now, let’s compile the source file with
CMake.
● Add the cmake_minimum_required
● Add the project
● Install libwebrtc if you haven’t yet
54
In a new CMakeLists.txt :
cmake_minimum_required( VERSION 3.3 )
project( SimpleApp )
55. WebRTC installer and CMake
Now, let’s compile the source file with
CMake.
● Add the cmake_minimum_required
● Add the project
● Install libwebrtc if you haven’t yet
● find_package() so you have access
to the library and configuration
55
In a new CMakeLists.txt :
cmake_minimum_required( VERSION 3.3 )
project( SimpleApp )
find_package( libwebrtc REQUIRED )
56. WebRTC installer and CMake
Now, let’s compile the source file with
CMake.
● Add the cmake_minimum_required
● Add the project
● Install libwebrtc if you haven’t yet
● find_package() so you have access
to the library
● ${WEBRTC_LIBRARIES} : this
variable includes all you need
56
In a new CMakeLists.txt :
cmake_minimum_required( VERSION 3.3 )
project( SimpleApp )
find_package( libwebrtc REQUIRED )
add_executable( SimpleApp SimpleApp.cc )
target_link_libraries( SimpleApp ${WEBRTC_LIBRARIES} )
58. WebRTC JSEP: QML Janus offer
● Janus Subscribe Flow
○ publishers
○ Create handle
○ subscribe
I got offer, let s give it to webrtc stack
58
59. WebRTC JSEP: C++ webrtc answer
● PeerconnectionFactory
● Peerconnection
● PeerconnectionObserver
○ setRemoteDescription()
○ createAnswer()
○ setLocalDescription()
● createSessionDescriptionObser
ver
I got an answer, let s give it back to QML
59
60. WebRTC JSEP: QML answer to janus and ack.
● Janus Subscribe Flow
○ Feed::new
○ Open
○ Answer
○ ....
Main.cpp
Main.qml
60