So, hi everyone again, leave you from OpenSIPs here and I'm going to be quickly going through
what has been happening in the last year and what is new in the latest OpenSIPs 3.3 release,
which is pretty much focused on IM and RCS and a bit of extensions to both IMS and on
the UC, on the call center side.
And the reason why we went this route with this iteration, because we have one major
release each year, is that we've talked to the community and also read a bit of papers
like this one from a Juniper saying that RCS is growing, it's getting more and more
adoption, the subscriber population is forecasted to grow to like at least two billion devices
within the next few years, so why not make a bit of additions on this part.
And one of the first, so here you can see hopefully the font is not too small, kind
of the entire ecosystem that we have in mind here, where OpenSIPs, we make all these like
microservices catering to various components of the platform, there is the MSRP protocol,
which I'm going to quickly go through, so we are seeing a relay there, there is also
some gatewaying necessity for clients which don't support MSRP yet, they still need to
be integrated with the platform.
There is gatewaying to the IMS side, using RCS capabilities and also the contact center.
And with the IAM, we have, this is what we had, the simple message SIP method, just a
request reply, nothing much past that, but then there is also this MSRP protocol which
is not that new, it's 15 years old, but so far we've just seen it as you could use some
other software for it, there was also the MSRP relay project that you could use, but
now there is the need to have this closer in OpenSIPs and gain more access, more control
over the sessions and that's why we went and implemented the protocol as well.
So for example, this enables features like the RCS I was talking about, you could see
RCS as a turbocharged SMS, so it's pretty much SMS with all of these nice capabilities
like read and write receipts, file transfer, photo sharing natively into the phone, you
don't need an OTT app like WhatsApp, iMessage to give you all of that, that is the idea
with RCS and it's why Google is pushing it forward and why Apple is pretty much reluctant
or neutral towards it because they already have the iMessage, so why also work on something
that conflicts with your own application, right?
So MSRP, not much time to go into it, maybe we can take a look at a couple of request
replies, so here you set up the session like a regular call and if we look at the SDP,
we get the source port that each side is advertising and from now on they will exchange these MSRP
messages, so it kind of looks like similar to SIP messages and in the payload we see
the messages, the chat part.
And this is how the stack looks in OpenSIPs, it's kind of a three layer architecture right
on the bottom, there is the protocol and if you're familiar with OpenSIPs you know the
other proto underscore modules, your TCP, your TLS, your WebSocket and all of those,
now there is the MSRP as well and the first module we built on top of it is the relay
which as the name suggests there is not that much going on but also it solves the problem
of authentication which is in the MSRP protocol, the auth method and it gives you some useful
callbacks to supply the credentials, right?
Also on the egress side it gives you the possibility to select the destination and that's pretty
much about the relay, the user agent is a bit more interesting in the sense that you
can interact with it in various ways, also first from the OpenSIPs configuration script
you have this, I'm going to show you some call flows so you can get an idea of how it
works but also through the management interface right which is HTTP based, so you get this,
you can implement it from your web applications for example and initiate and control sessions
that way, for example, okay so there are no animations, so here if we take them from top
to bottom we can see an example of a web app that is obviously not MSRP enabled, talking
to an MSRP enabled application like a web phone and on the app side you use MI, right,
like HTTP invocations, like start session, send message or end session which get nicely
converted on the outbound leg to SIP calls, right, it's a SIP call that then only has
these MSRP mid-dialogue messages and on the other direction the SIP calls initiated by
the MSRP phone get converted into events for the application, you can subscribe to it via
whatever channel you want to receive them on, JSONRPC or stuff like that, so the next
one was the gateway, right, the MSRP gateway that helps us include the classic SIP clients
which are only capable of SIP message, right, they don't know MSRP but it does this nice
conversion of like these simple request reply messages, it actually converts them to a session
with the MSRP enabled phone, so these sessions are kept by open SIPs transparently and they
are even closed, for example, since there is no way of knowing when it decides to stop
a chat, for example, right, we just close them based on inactivity, we just time them
out, whereas, so this is when the simple, one minute left, okay, okay, so that is pretty
much on the gateway, the call center, some additions here, right, because now we got
some more types of workloads or capabilities for the call center agents, they can handle
both chat messages and voice, so a cool thing about chats is that now they can do parallel
work, right, you can do two calls at the same time but you can have four chat windows open,
so there is this problem of balancing the incoming requests in the queue, right, you
have calls and chats and from various parts of the platform and now there is this problem
of correctly balancing them to your available agent based on their capabilities, right,
some of them may have chat enabled in their application, some of them not and there are
few modes to control that and on the MS side, of course, the possibility to build custom
diameter requests and pretty much that's it on the, on the UC side and DIMAS and RCS,
a couple more additions on status and reporting, so now OpenSIPS is a lot more verbose with
regards to how its internal state looks like, some additions on the TCP engine also giving
control of TCP connections and that's about it as far as I have here with OpenSIPS 33
and I would like to welcome everybody to the newly announced OpenSIPS conference this year
for where we will be unveiling what's been going on with the 3.4 and what we are working
on on that side and with that, I'm not sure if there are any more questions but thank
you for your attention.