[Autogenerated] let's now turn our attention to UWP process is
known as the Universal Windows platform processes.
So this had many names in the past that started out life as metro applications
at the time in Windows eight when they were first introduced.
And then because of some trade conflict,
the name has changed multiple times to store applications.
Modern applications sometimes simply apps but now the going forward
name is Universal Windows platform applications.
These applications are typically the ones you download
from the Microsoft store and can be installed on multiple
types of Windows form factors, not just the normal Windows,
but also Windows phone, the Hololens device,
even xbox one, they all are built around the Windows runtime.
The Windows runtime is the platform and API that was created to help
build these kinds of applications in a universal way.
Universal here, of course is limited to Microsoft's universe.
And one of the things about this process is is that they
declare capabilities not to do things and it's very similar to
the model you find in the mobile world, in the mobile world,
if you go to a store that you're using,
you always see something like the process or the
application wants to use your microphone,
your camera to have access to your documents and things
like that and it's up to the user to decide whether the
user is okay with that or not.
If he or she is then they can download the application and get it installed.
If not, then just don't do that.
And so the way it's done in UWP is by using these capabilities which are
declared officially in something called nXML manifest,
which is just submitted data that can be and in fact is
necessary when building these kinds of applications.
So we have these capabilities and then they're going to be
shown on the store page of the application.
Once it gets approved and using these capabilities,
the application can do stuff by the way.
Even with these capabilities.
In many cases the process doesn't have enough power to do the actual
operations and it needs helper called the runtime broker,
which is like a helper process that performs the operations once these
capabilities are properly declared by the real application.
So one of the properties of this process that in terms of security
they are fairly weak and that should give the users a good sense of
uh of safety when the dialogue these applications and they should
feel okay because these processes can't really hurt the system in
almost no discernible way.
And this is implemented using something called an app container,
which is a security sandbox sandbox of sorts.
It's not true sandbox,
but it does provide some sand boxing capabilities and we'll
discuss some of those in a future course.
In addition,
we've seen already in the previous course that when we do
things like minimize such a window that belongs to one of
these applications or processes,
all the threads there become suspended so they get some kind of
extra management by these two components known as the process
state management manager and the process lifetime manager and they
provide two different services, so to speak,
we have suspension and resumption.
So this is uh something that we've seen already when the threats get
suspended in such a process becomes minimized or one of its windows
becomes minimized and restored properly.
Uh the threats resume but there's also another thing that could
happen to this process is that they could terminate,
attaining given point in time without any special further now
notice and this is done because for example,
the system is very low on memory.
The system is very low on memory.
The first things to go are UWP processes and that's because
these process are expected to save state often.
So the next time the launch they get information saying,
hey you were launched because um you might have been
terminated previously or perhaps that's a new launch and
application should do the right thing.
In this case,
termination can also occur because of some misbehavior by the
applications such as consuming too much memory.
There are some limits that Windows imposes on UWP processes
so they don't consume too many resources.
So obviously these are useful when you want to create
applications that run on multiple form factors,
but normal applications that are not UWP don't suffer so to speak from
these limitations but they cannot be run on any kind of Windows device
without first doing proper checking.
In fact some of these normal applications,
with 32 applications are not officially supported on non normal
standard laptop or desktop based systems.
So let's see some of these aspects of UWP processes.