News from Industry

WebRTC GetUserMedia is more important than the rest of this communication stack.

Who would have believed? With all the magic and distraction that video calling from a browser brings with it, the real treasure trove resides in the basics – WebRTC GetUserMedia.

Simplifying things, WebRTC has 3 distinct areas/APIs to it:

1. GetUserMedia, allowing access to camera and microphone inside the browser
2. PeerConnection, taking care of all the mess that is a voice/video call
3. Data Channel, making it possible to send any arbitrary message across browsers directly

I’ve pointed up in the past how WebRTC GetUserMedia gets used by Mailchimp and WhatsApp. Taking a camera snapshot is nice, but what else can we achieve with this access we’ve been given?

TalkLessNow

Chris Kranky had an idea a few weeks ago. Measuring how much you’re yapping in a call as opposed to listening. So he made it happen. On a shoestring budget, some connections and a bit of time and TalkLessNow was born.

How it works?

The website is quite spartan. When you go on a phone call (not a WebRTC one), you just press the green Call button on talklessnow.com.

The code on the site “listens” through the machine’s microphone to your call. Whenever it hears enough of a volume – it assumes you’re talking. If the volume is lower than its configured threshold – you’re listening.

Just WebRTC GetUserMedia. No PeerConnection or any other fuss.

Will it work?

Here in Israel, I am sure the results won’t be good. We’re used to talking over each other and interrupting. Efficiency at its best. If in a call between Israelis it shows less than 70% of talk time per participant, I’ll crown that session a success.

Seriously though, we should be listening a lot more than we’re talking.

Same but different

The now defunct Guitar Tuner works the same way. It doesn’t work anymore because the site is served on HTTP and WebRTC GetUserMedia now requires HTTPS to work with the latest Chrome release (progress, you know).

Ziggeo

Here’s another example.

Ziggeo is making use of WebRTC to record videos. They do that by employing WebRTC GetUserMedia, storing the resulting media locally and at the end of the recording sending it to their servers. The sending part doesn’t occur via WebRTC.

There’s an interesting interview with Susan Danziger, CEO of Ziggeo from last week that you should read.

Is this Real Time Communications?

WHO CARES?

It works. It gives business value – and in ways that weren’t really possible up until today.

There’s a lot more to WebRTC than classic VoIP.

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The Hidden Gems of WebRTC Goodness May Well Lie Within GetUserMedia Itself appeared first on BlogGeek.me.

The FreeSWITCH project is nearly ten years old, and the FreeSWITCH git repo has commits from about 214 different authors and over 3.2 million lines of code with 875k of those lines under the src directory. Some of the maintenance challenges associated with such a large software project include: detecting and resolving human errors such as typos, logic inversions, and dangerous formatting. Implementing code review is a must, and there are different techniques common to the industry used to reduce the defect density and standardize the code format: autobuilding against multiple compilers, routine testing, and static code analysis. The core development team at FreeSWITCH uses all three techniques.

Both autobuilding and routine testing can be applied with in-house system workflows. Routinely building the packages against different compilers allows for consistent tracking to make sure additional commits won’t break existing code in any of the prepackaged builds. This also allows for consistent handling of packages for multiple operating systems. By autobuilding against different compilers, we can make sure that a commit for one set of packages doesn’t break the builds for the others. Routine testing is another viable option for code review, and routinely testing and implementing a bug tracking system allows the community members to report bugs found in unique environmental circumstances. Open-source software relies on many different eyes to keep bugs shallow, and this practice opens up different configurations and applications of the software for a more thorough testing. Each year hundreds of tickets are opened on the FreeSWITCH project JIRA, and the developers work tirelessly to address all of them.

Static analyzers can scan thousands to millions of lines of code without getting tired and usually don’t require many manual steps to run. The relationship between a project’s developers and the creators of a static code analyzer can be a symbiotic one. The analyzer works by using a database of multiple tiers of positive and negative heuristics. First, it runs the low cost patterns against the entire code base to generate a large list of possible issues, then runs more accurate and higher cost patterns against the bug candidates to reduce the number of false positives, and finally evaluates the severity and more accurately classifies the issues. Once the analyzer has completed its run, it requires an experienced software developer familiar with the code base to review each issue reported.

Most static analyzers are built to report possible candidates in the first pass, and thus immature analyzers are perceived to red flag everything. They tend to create a lot of noise by reporting a large number of false positives and misclassifying the severity of issues. After the developers for the software being analyzed have reviewed the results of the analysis, they can give specific examples of why they determined it to be a false positive which can be used to improve the static analyzer’s heuristics. As the database matures, the quality of the negative heuristics improves and reduces the volume of false positives. The advantage here is that each report triaged leads to a commit resolving a bug or an improvement to the analyzer.

The team over at Program Verification Systems have built a static analyzer for C/C++ code that integrates into Microsoft Visual Studio. According to their website, the program allows the user to scan of lines of code to locate various typos and other errors. Their analyzer supports C/C++, C++/CLI, and C++/CX with support for C# language coming soon. The PVS-Studio is also available as a standalone utility through the distribution packages which allows for viewing the analysis logs on a machine without Visual Studio. It can also be used to track multiple sub-builds and analyze non-standard build systems. The reports for the open-source projects that have been analyzed with this software can be found on their website in the Checked Projects section.

The FreeSWITCH team ran the open-source FreeSWITCH project through the PVS analyzer. A decent majority of the issues reviewed were determined to be minor Windows-specific bugs not previously flagged by compilers currently implemented by the team. The team is continuing to review and resolve the alerts from the analysis and have integrated this analyzer into the code review workflow. They look forward to continuing this symbiotic relationship with the goal of improving the quality of software.

If you would like to replicate the results you can use the following steps.

• Set up an instance of Microsoft Windows 10, install Microsoft Visual Studio 2015, and install the analyzer from the http://www.viva64.com/en/ website.
  

• Create a new FreeSWITCH project.
  

• Clone the FreeSWITCH repo into your project.
  

• Open the FreeSWITCH project.
  

• Set the debug to ‘x64’ if not already set.
  

• Click the PVS studio drop down box and select “check solution” to run the analyzer.
  

• Settle in and wait for the results.
  

Our features this week include: improvements to the auto bitrate features in mod_conference, the addition of the Debian install script for the verto communicator, and separate controls for gain and volume for verto. Join us Wednesdays at 12:00 CT for some more FreeSWITCH fun! This week we have Tsahi Levent-Levi talking about WebRTC! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8595 [mod_conference] Improve auto bitrate in personal canvas mode and do not let auto bitrate exceed native picture size

Improvements in build system, cross platform support, and packaging:

• FS-8614 [verto_communicator] Add Debian developers install script and update README.md to reference it

The following bugs were squashed:

• FS-8585 [mod_commands] Expanded {} and <> to [] for each dial string in group_call to allow for multiple device registrations for the same user
• FS-8589 [mod_conference] Fixed using conference playback with full-screen=true not working correctly
• FS-8354 [mod_conference] Fixed G722 audio issues with mod_conference caused by previous commit fab43547
• FS-8602 [mod_conference] Fixed conference not auto-generating layouts properly when callers with no camera are present
• FS-8615 [mod_conference] Fixed a crash when quickly changing layouts and setting reservation ids
• FS-8588 [mod_httapi] Fixed a crash found while fixing unreliable digit collection
• FS-8599 [verto] Removed a workaround for Mozilla that is no longer needed for video size
• FS-8590 [verto_communicator] Fixed sending malformed vid-res-id command when changing layouts by treating no res-id the same as clear
• FS-8612 [core] Fixed a rare IVR originated calls crash due to read codec leak
• FS-8619 [mod_rayo] Reply with conflict stanza error if bind is attempted with duplicate JID. Improve error handling when ‘ready’ callback fails.

The FreeSWITCH 1.4 branch had a couple of bug fixes back ported. And again, keep in mind that 1.4 is quickly moving toward end of life and won’t be supported any longer except for high level security issues.

The following bugs were squashed:

• FS-8582 [mod_httapi] Fixed a crashed caused by null URL being passed

 

Links: http://www.dslreports.com/speedtest 

Links:https://support.flowroute.com/customer/en/portal/articles/2205573-freeswitch—add-flowroute-as-sip-gatewayhttps://developer.flowroute.com/

The future isn’t what it used to be.

I’ve been babbling here a lot about the enterprise video conferencing market and WebRTC’s role in disrupting it. When it first came out, I believed the existing companies are going to be struggling with it. I was mostly ignored by these companies – it is hard to see what’s just around the corner when you’re stuck in the echo chamber of your company and its immediate industry.

When I meet old colleagues of mine from the video conferencing industry and see them working in the same companies, I suggest they leave. Find another company or industry, because the outcome is known – just the timing factor is missing. They dismiss it, probably thinking that I am saying it our of a grudge to the company. I am not.

What happened in November should hit home.

We had two separate news items that in some cosmic way happened in the same week:

1. Cisco acquired Acano. For $700M USD. A company with around 350 employees (that’s $2M per employee)
2. Polycom announced closing its Israeli office. Moving the operations to India. That’s 200 employees + 80 contractors

Dumbing things down a bit:

• Acano was about building a cloud MCU. Polycom Israel was about building an on-premise MCU
• Acano started life in 2012, making immediate use of WebRTC. Polycom just launched their first MCU to support WebRTC this year (2015)

It isn’t that WebRTC is the reason why Acano succeeded and Polycom Israel has failed. It is that the mindset of these two companies was different. Acano looked into what can be done in this modern age and made use of WebRTC to get there. Polycom looked at how they slowly evolve their product offering. I am sure people in Polycom knew about WebRTC. It probably was on roadmaps and discussions since 2012, never to be given priority, because who needs it? It can’t compete with the high end systems of Polycom. But then the basis of competition changed. What customers care about changed. It isn’t anymore about resolutions and frame rates. It’s about utility and usability – something most video conferencing companies never knew how to handle.

Polycom Israel didn’t have the foresight to make themselves attractive enough to their corporate overlords in San Jose. Probably because they weren’t given the opportunity to do so. The end result? They just weren’t important. Their technology and architecture is now stable and understood enough to move it to countries with lower salaries.

—

I remember doing a training to developers about WebRTC in 2014. I asked people in the room what they do. There were media engineers and signaling protocols developers. I told them that they are going to be out of work. They saw it as a joke. Some of them are now updating their resume.

What is it that you are doing for a living? What is your company developing? Does it make sense? Do you take the effect WebRTC (and other technologies) have on your job seriously?

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The First WebRTC Earthquake in Video Conferencing: Acano vs Polycom appeared first on BlogGeek.me.

Kamailio project is pleased to announce that the date and location for next Kamailio World Conference and Exhibition were decided – May 18-20, 2016, in Berlin, Germany.Kamailio project is celebrating 15 years of development in 2016, therefore we plan to have a special edition, many guests that impacted the evolution of the project since its start in 2001 at FhG Fokus Institute.Website of the event and call for presentations will be launched very soon. Meanwhile, if you haven’t participated at a past edition, you can check the previous edition website in order to get an idea about the structure and content of the event:

• http://www.kamailioworld.com/k03/

Keep an eye on this news feed for updates in the near future!

During the Kamailio IRC level meeting this summer, a need for refreshing the logotype of the project was discussed. The current (embedded in the upper right corner of kamailio.org main page) is based on the one used for during the former OpenSER name of the project, with changes of the text to reflect the SIP Router and Kamailio names, somehow not longer very balanced, lacking good quality and high resolution graphics. The participants agreed that a refresh would be better than keeping that version.One option was to reuse the graphics from Kamailio World Conference logo, simply with Kamailio name. It was used even before as alternative logo by various peoples and companies.We now want to finish this process and we considered also the possibility of a new logo design. Thanks to Asipto and their deal with 99Designs, we ran a design contest and see if someone proposes an interesting logotype. Based on the result of the contest, followed by discussions on management group and the people interested in updating the logotype, we are proposing a new logo for the project:During the next days we are expecting feedback from community, especially if it looks too similar with other logos they know or if they like it or not. Based on that, a final decision will be taken and either we will switch to the new proposed logo or keep looking for a new one.Join the discussion about the new logo on users mailing list: [email protected] .2D and 3D variants in different formats, as well as some combinations with few pictures, can be found at:

• https://www.kamailio.org/pub/kamailio-logos/new/

As a preview, a few variants are embedded here:

isVisible=false; function show_hide_searchbox(w){ if(isVisible){ document.getElementById('filterBoxSelection').style.display = 'none'; w.innerText='Filter ▼'; }else{ document.getElementById('filterBoxSelection').style.display = 'block'; w.innerText='Filter ▲'; } isVisible=!isVisible; } function checkIfSelected(chk){ if(chk.checked==1) chk.parentNode.className = "selected"; else chk.parentNode.className = "notselected"; getSelectedValues(); } function getSelectedValues(){ var a=document.getElementsByClassName('selected'); var vtVal=[] , ctVal=[] , ftVal=[]; var ct=0,vt=0,ft=0; for (x = 0; x < a.length; ++x) { try{ if(a[x].getElementsByTagName('input')[0].className=='companyType'){ ctVal[ct]= a[x].getElementsByTagName('input')[0].value; ct++; } if(a[x].getElementsByTagName('input')[0].className=='vendorType'){ vtVal[vt]= a[x].getElementsByTagName('input')[0].value; vt++; } if(a[x].getElementsByTagName('input')[0].className=='focusType'){ ftVal[ft]= a[x].getElementsByTagName('input')[0].value; ft++; } }catch(err){ } } search_VType(vtVal); search_CType(ctVal); search_FType(ftVal); } function search_VType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null){ a[x].style.display='block'; } } if(val.length==0){ a[x].style.display='block'; } } } function search_CType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null && a[x].style.display=='block'){ break; } if(i==val.length-1){ a[x].style.display='none'; } } } } function search_FType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null && a[x].style.display=='block'){ break; } if(i==val.length-1){ a[x].style.display='none'; } } } }Check out all webRTC interviews >>

Ziggeo: Susan Danziger

December 2015

Video recording

Other

Small

Video

Asynchronous video meets WebRTC.

[If you are new around here, then you should know I’ve been writing about WebRTC lately. You can skim through the WebRTC post series or just read what WebRTC is all about.]

One area where WebRTC is making strides recently is video streaming. Some of the hyped use cases today are those that enable broadcasting in real time, but there’s another interesting approach – one where WebRTC is employed when the video consumption is asynchronous from its creation.

Ziggeo is an API provider in this specific niche. I met with Susan Danziger, CEO of Ziggeo, and asked her to share a bit of what it is they do with WebRTC and how it is being adopted by their customers.

 

What is Ziggeo all about?

Ziggeo is the leader in asynchronous (recorded) video offering a programmable video recorder/player through our API/native SDKs.

 

You started by working on an HR interviews platform. What made you pivot towards a video recording API platform instead?

In building our own video recording/playback solution for the platform, we realized what a complicated and time-consuming process building our own solution was.  We had to make sure that videos could be recorded and played across all devices and browsers (even as new ones were released) and build a permissions-based security solution that would withstand hackers.  We were surprised there were no off-the-shelf solutions available so decided a bigger opportunity would be to release our technology as an API — and then native SDKs (and shortly thereafter closed our B2C platform).

 

On the same token – you have Flash there. Why did you add WebRTC? Wasn’t Flash enough for your needs?

For the most part our customers hate Flash.  And no wonder: browsers that support Flash have an awful user experience in which you need to basically hit 3 different buttons before you can begin recording from your web camera (once to resume the suspended Flash applet and twice to access the camera).

We added WebRTC to avoid Flash whenever possible.  That said, for certain browsers, e.g. Safari and Internet Explorer we need to default to Flash as they don’t yet support WebRTC.

 

How are customers reacting to the introduction of WebRTC to Ziggeo?

Customers love it!  In fact, our customers seek us out in part because we’re the only API for asynchronous video recording that supports WebRTC.

 

Can you share a few ways customers are using Ziggeo?

In addition to recruiting (where candidates introduce themselves on video), we’ve seen Ziggeo used for training (e.g. trainees record video sales pitches for feedback); dating (potential dates exchange video messages); “Ask Me Anything” (both questions and responses on video); e-commerce (products introduced on video and video reviews recorded); advertising (user-generated videos submitted for contests or for use in commercials); and journalism (crowd-sourcing videos for news from around the world).  I’m still waiting for someone to create a video version of Wikipedia where pieces of knowledge are recorded on video from around the world — that would be the most amazing use case of all.

 

A video version of Wikipedia. Have it in Hebrew and I’ll sign up my daughter on it.

You don’t use the Peer Connection APIs at all – Just getUserMedia. Why did you make the decision to record locally and not use the Peer Connection and record on the server?

Folks like to re-record locally so we chose not to use unnecessary resources.  We pride ourselves on making our technology as efficient and seamless as possible.

How do you store the file locally and how do you then get it to your data centers?

We use IndexedDB to store the file locally and then push it using chunked http.

 

Viewing. Over what protocols do you do it, and how do you handle the different codecs and file formats?

Protocols: Http pseudo streaming, HLS, rtmp, rtsp

Formats: we transcode videos to different formats (mp4, webm) and resolutions

 

Where do you see WebRTC going in 2-5 years?

We imagine there will be full support of WebRTC across all browsers and devices as well as better support for client-side encoding of video data.

 

Given the opportunity, what would you change in WebRTC?

We’d like to see improved support for consistent resolution settings as well as for encoding

 

What’s next?

We’re planning the 2nd Annual Video Hack Day in NYC for this coming May.  You can find more information here at: videohackday.com or follow @videohacknyc on Twitter

–

The interviews are intended to give different viewpoints than my own – you can read more WebRTC interviews.

The post Ziggeo and WebRTC: An Interview With Susan Danziger appeared first on BlogGeek.me.

This week we had a few features including: allowing building with OpenSSL without EC support, a video quality parameter to allow for conference configuration for verto, and some improvements to conference layouts for verto as well. If you haven’t already, it is highly recommended that you upgrade to the newest 1.6 release as soon as possible to avoid the vulnerability from last week. Join us Wednesdays at 12:00 CT for some more FreeSWITCH fun! This week we have James Tagg! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8568 [core] Allow building using system OpenSSL without EC support
• FS-8293 [verto][mod_conference] Made sanity level based on 1080p and added a video-quality conference profile parameter for specifying the motion factor when calculating video bitrate, defaulting to 1.
• FS-8264 [verto_communicator][verto]  Adapted the layout select to new response, added a separated menu in members list to set its reservation id, and added all the reservation IDs in the return of “list-videoLayouts” command
• FS-8433 [mod_sofia] Allow hangup cause to be set inside redirect data

Improvements in build system, cross platform support, and packaging:

• FS-8592 [Windows] Fixed some simple compiler errors
• FS-8578 [mod_verto] Fixed build error for missing __bswap_64 on osx
• FS-8152 [Debian] Make sure to package the image directories too
• FS-8576 [Debian] Fixed a package upgrade issue related to the fonts being installed in multiple packages

The following bugs were squashed:

• FS-8569 [mod_conference] Fixed undefined symbol conference_cdr_test_mflag
• FS-8574 [mod_conference] Fixed a read write lock issue
• FS-8566 [core] Fixed calls failing when put on hold in bypass media mode with inbound late negotiation set to false
• FS-8573 [core] Fixed one way audio after resuming from hold in bypass media mode
• FS-8575 [core] Fixed DTMF not being passed from a to b during rfc 2833 events
• FS-8582 [mod_httapi] Fixed a crashed caused by null URL being passed

 

The FreeSWITCH 1.4 branch had a couple of bug fixes back ported as well as the release of 1.4.26. And again, keep in mind that 1.4 is quickly moving toward end of life and won’t be supported any longer except for high level security issues.

New features that were added:

• FS-8547 [core] Add error log into stats to log when quality impacting events begin and end

The following bugs were squashed:

• FS-8537 [mod_lua] Fixed a segfault caused by passing nil to various lua functions

Atom is an open source editor developed by Github. One of its useful features is ability to preview the markdown files while editing them. The Kamailio source tree includes a few such markdown files (e.g., README.md in the root folder). They are nicely displayed when browsing the GIT repository at github.com.Another feature would be auto-completion suggestion based on the content of the edited file, so, for example, if you define a route block, then its name appears when adding the statement to execute that route.A syntax highlighting package for kamailio.cfg has been made available at:

• https://github.com/miconda/atom-extensions/tree/master/language-kamailio

Information about how to install it are available in the readme at the above link.For now, it does rather basic matching of configuration file elements, still relevant to make them easier to spot. Contributions to enhance it are more than welcome!A screenshot with a part of default configuration:.Enjoy!

You are not always connected.

You are not always connected.

You are not always connected.

Truely you aren’t.

I know you like to think you are, but get over it – this isn’t the case.

From the unveiling of AWS IOT platform @ re:Invent 2015

Every week I need to take my daughter to her artistic gymnastics lessons. And then I have 90 minutes of quality time. With myself. While I usually use it to continue reading on my Kindle, I try once in awhile to actually work at that time. The problem is, that the cellular reception in the waiting hall is less than satisfactory and the mosquitoes make it impossible to sit outside – where it is a lot nicer with much better reception.

I quickly learned that working there is close to impossible, as reception is flaky – not something I can rely on with my line of work which requires an intravenous internet connection at all times. But there are quick things that I can do at that time – which most usually than not includes messaging.

Offline Messaging

Here’s what I found out about the 3 top messaging apps on my phone recently:

 

WhatsApp

WhatsApp rocks when it comes to be able to send messages even when I am offline. It uses the store and forward technique both on the client and on the server:

• If the user has no internet connection, the message is stored locally until such a connection is restored. This approach works only for text messages – you can share images or videos with it
• If the receiver has no internet connection, then the message is stored on the WhatsApp server until a point in time when the recipient is available – this works for all types of messages

You just can’t ask for more.

Google Hangouts

Google Hangouts is rather poor when it comes to offline behavior. I does manage its own store and forward mechanism on the server side, which means that if you send a message when you are online – the recipient will see it when he becomes online.

But, you can’t send anything if you aren’t online. Hangouts isn’t kind enough to store it locally until you are online.

This makes for a poor experience for me in that gymnasium waiting room, where the network comes and goes as it pleases. Or when I am riding the elevator going downstairs from my apartment and need to send some quick messages.

Slack

Slack needs to be connected. At least as far as my understanding of it is.

If you open the app, it tries to connect. If you send a message while it is connected – great.

If you try sending when it isn’t connected – it will fail.

But sometimes, it believes that it is connected and it isn’t. In such a case, killing the Android app and restarting it will be the only remedy to be able to send anything out.

Yuck.

Offline Frameworks

Communication frameworks are tricky. The idea is that you have a network to be able to communicate, but as we’ve just seen – this isn’t always the case.

So where do we stand with different frameworks? I had these 3 examples readily available out the top of my head for you:

Matrix History Storage

Matrix (interviewed here in the past) also went to great lengths to deal with offline scenarios. In the case of Matrix, it was about decentralization of the network itself, and how can you “self heal” and synchronized servers that go down min-conversation.

This makes it easy to add and remove servers during runtime, but it doesn’t help me in my daughter’s gymnasium class. I haven’t found any information stating that Matrix can (or can’t) send a message while the sender client is offline.

Twilio and Message History

Twilio announced its own IP Messaging capability. While this isn’t yet generally available, the concepts behind these APIs are outlined on that page.

To make things simple – it includes store and forward on the server (recipient can be offline when sender sends and vice versa); but it probably doesn’t include sending while the sender is offline.

As this is still under development/testing, my suggestion would be to add the “sender is offline” scenario and support it from the SDK.

Amazon Device Shadow

At AWS re:Invent 2015, Amazon unveiled its IOT platform – the building blocks it has on offer for the Internet of Things.

In many ways, the Internet of Things is… connected. But in many other ways it might not be connected at all times. I’ve seen several interesting IOT frameworks overcome these in various means. Here’s AWS take on it – they create what they call a device shadow.

 

Werner Vogels does a great job of explaining this. I suggest viewing the whole session and not just the 1 minute explainer on device shadow.

Why is it important?

We are never always truly online. As messaging becomes one of the central means of communicating – both between people as well as devices – it needs to take this into account. This means covering as many offline use cases as possible and not just assume everything is connected.

Doing this can be tricky to get right, and in many cases, it would preferable for developers to go with a solid framework or a service as opposed to building it on their own. What most frameworks still miss today is that nagging ability to send a message while the user is offline – storing it locally and sending once he comes online.

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The Unconnected Messaging World appeared first on BlogGeek.me.

We are currently having a special Black Friday sale, save $500 on your FreeSWITCH Bootcamp ticket - use the code: “blackfriday” to save now.

The FreeSWITCH Bootcamp is an intense three-day training, providing in-depth coverage of FreeSWITCH installation, configuration, maintenance and programming so that you can build your business. The bootcamp will be hosted in our brand new office in beautiful San Francisco. Go into the bootcamp as a Novice – and come out as a FreeSWITCH guru. Early bird pricing lasts until November 27th, but register now as there are limited spaces available.

Register Now! https://kazoosf.eventbrite.com

Thanks to Victor Seva from Sipwise, the Travis-CI jobs for building Kamailio were upgraded to useDocker containers.A part of continuous integration process for Kamailio project, the builds are triggered by commits to master and stable branches, helping to detect compilation issues on different OS distributions, which typically happen due to different versions of libraries.The bonus is that the same build system can be used locally by anyone, being it developer or VoIP engineer. Quite useful in cases when one wants to backport patches or develop its own extensions.You can read the description of the build system as well as get the scripts from the source code of Kamailio, in the folder test/travis-ci. You can browse the content of the folder online at:

• https://github.com/kamailio/kamailio/tree/master/test/travis

Enjoy!

Open-Source is an enormous component of what powers 2600Hz. Not only are we supporting and contributing to other open-source projects, the Kazoo platform is open-source. Open-source projects have been essential in building our incredible communications systems and we want to thank anyone who has contributed to our open infrastructure.

The Kazoo platform has been growing exponentially over the past five years and its scalability was recently validated at KazooCon. This October, over 200 people were in attendance at KazooCon, representing over twenty states and fourteen countries. We were blown away by the level of support of our platform, and in addition had largest Kazoo training following the conference.

Outside of the United States, our contributions have also taken off. Russia in fact, has garnered a very dedicated following. As of now, our top three 2015 contributors all hail from Russia.

We’re proud to announce that some of our Russian contributors of the Kazoo platform will be hosting Kazoo’s first independent community conference. Representatives from SIPLABS, Zebra Telecom, Telecom13, and OnNet will discuss how they’ve been utilizing the Kazoo platform. This will take place November 26th in Moscow. KAZOOMEETUP MOSCOW 2015 was conceived as a conference of users, developers, or people simply interested in our open telecommunications platform. 

So join our Russian friends as they host their first Kazoo meetup, and learn about Kazoo’s open-source contributions. Click Here.

Kamailio SIP Server v4.3.4 stable is out – a minor release including fixes in code and documentation since v4.3.3. The configuration file and database schema compatibility is preserved.Kamailio (former OpenSER) v4.3.4 is based on the latest version of GIT branch 4.3, therefore those running previous 4.3.x versions are advised to upgrade. There is no change that has to be done to configuration file or database structure comparing with older v4.3.x.Resources for Kamailio version 4.3.4Source tarballs are available at:

• http://www.kamailio.org/pub/kamailio/4.3.4/src/

Detailed changelog:

• http://www.kamailio.org/pub/kamailio/4.3.4/ChangeLog

Download via GIT: # git clone git://git.kamailio.org/kamailio kamailio
# cd kamailio
# git checkout -b 4.3 origin/4.3Binaries and packages will be uploaded at:

• http://www.kamailio.org/pub/kamailio/4.3.4/

Modules’ documentation:

• http://www.kamailio.org/docs/modules/4.3.x/

What is new in 4.3.x release series is summarized in the announcement of v4.3.0:

• http://www.kamailio.org/w/kamailio-v4-3-0-release-notes/

PS: note the dates and location for next Kamailio World – May 18-20, 2016, in Berlin, Germany – it is going to be a special edition, with Kamailio project celebrating 15 years of development.

2600hz is hosting a FreeSWITCH boot camp! Get in on the action to learn the ins and outs of FreeSWITCH! The FreeSWITCH Bootcamp is an intense three-day training, providing in-depth coverage of FreeSWITCH installation, configuration, maintenance and programming so that you can build your business. The bootcamp will be hosted in the brand new office in beautiful San Francisco. Go into the bootcamp as a Novice — and come out as a FreeSWITCH guru. Early bird pricing lasts until November 27th, but register now as there are limited spaces available! https://goo.gl/zbS4tP

Machine learning and artificial intelligence in messaging will become commonplace.

Who would have thought that the most personal and manual form of interaction between humans can be mechanized? Years a go, it started with presence and instant messaging. People found out ways to communicate other than the phone call. Today, messaging is so prevalent that you have to take it seriously:

• In the consumer space, we’re talking about a billion users for these platforms. WhatsApp at 900 million is the closest to reach its first billion soon enough
• In the enterprise space, a single hiccup of Slack yesterday, sending many to vent off on Twitter

What is interesting, is how artificial intelligence is starting to find a home in messaging apps – consumer or enterprise ones – and where this all is headed.

I couldn’t care less at this moment if the interface is textual or speech driven. I might cover this in a later article, but for now, let’s just assume this is the means to an end.

Here are a few examples of what artificial intelligence in messaging really means:

The Silent Administrator

You are in a conversation with a friend. Chatting along, discussing that restaurant you want to go to. You end up deciding to meet there next week for lunch.

I do this once a month with my buddies from school. We meet for lunch together, talking about nothing and everything at the same time. For me, this conversation takes place on WhatsApp and ends up as an event on my Google Calendar.

Wouldn’t it be nice to have that event created auto-magically just because I’ve agreed with my friends on the date, time and place of this lunch?

This isn’t as far fetched as it seems – Google is already doing similar stuff in Google Now:

• Prodding me when the time comes to start the commute to a meeting
• Tracking flight delays when it finds an itinerary in my Gmail
• Giving me the weather forecast on mornings, and indicating “drastic” weather changes the night before
• Providing multiple time zones when I travel

Google Now is currently connecting to apps on the phone through its Google Now on Tap, giving it smarts over a larger portion of our activities on our phones.

Why shouldn’t it connect to Hangouts or any other messaging service scouring it for action items to take for me? Be my trusted silent administrator in the back.

A few years ago, a startup here in Israel, whose name I fail to remember, tried doing something similar to the phone call – get you on a call, then serve ads based on what is being said. Ads here are supposed to be contextual and very relevant to what it is you are looking for. I think this is happening sans ads – by giving me directly what I need from my own conversations, the utility of these messaging services grows. With a billion users to tap to, this can be monetized in other means (such as revenue sharing with service providers that get promoted/used via conversations – booking an Uber taxi or a restaurant table should be the obvious examples).

In the enterprise space, the best example is the Slackbot, which can automate interactions on Slack for a user. No wonder they are beefing up their machine learning and data science teams around it.

Knowledge base Connectivity

That “chat with us” button/widget that gets embedded into enterprise websites, connecting users with agents? Is it really meant to connect you to a live agent?

When you interact with a company through such a widget, you sometimes interact today with a bot. An automated type of an “answering machine” texting you back. It reduces the load on the live agents and enables greater scalability.

This bot isn’t only used to collect information – it can also be used to offer answers – by scouring the website for you, indexing and searching knowledge bases or from past interactions the live agent had with other users.

I recently did a seminar to a large company in the contact center space. There was a rather strong statement made there – that the IVR of the future will replace the human agents completely, offering people the answers and support they need. This is achieved by artificial intelligence. And in a way, is part of the future of messaging.

Speaking with Brands

If you take the previous alternative and enhance it a bit, the future of messaging may lie with us talking to brands from it.

As messaging apps are becoming platforms, ones where brands and developers can connect to the user base and interact with them – we are bound to see this turning into yet another channel in our path towards omnichannel interactions with customers. The beauty of this channel is its ability to automate far better than all the rest – it is designed and built in a way that makes it easier to achieve.

Due to the need to scale this, brands will opt for automation – artificial intelligence used for these interactions, as opposed to putting “humans on the line”.

This can enable an airliner to sell their flight tickers through a messaging service and continue the conversation around that flight plans with the customer throughout the experience – all within the same context.

The Virtual Assistant / Concierge

Siri? Cortana? Facebook M? Google Search?

These are all geared towards answering a question. You voice your needs. And they go searching for an answer.

These virtual assistants, as well as many other such assistants cropping up from start ups, can find a home inside messaging platforms – this is where we chat and voice are requests anyway, so why not do these interactions there?

Today they are mostly separated as they come from the operating system vendors. For Facebook, though, Facebook M, their concierge service, Messenger is the tool  of choice to deliver the service. It is easy to see how this gets wrapped into the largest messaging platforms as an additional capability – one that will grow and improve with time.

Why is this important?

Artificial Intelligence is becoming cool again. Google just open sourced their machine learning project called TensorFlow. Three days go by, and Microsoft answers with an open source project of its own – DMTK (Microsoft Distributed Machine Learning Toolkit). Newspapers are experimenting with machine written news articles.

Messaging platforms have shown us the way both in the consumer market and in the enterprise. They are already integration decision engines and proactive components and bots. The next step is machine learning and from there the road to artificial intelligence in messaging isn’t a long one.

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The Role of Artificial Intelligence in Messaging appeared first on BlogGeek.me.

This week we had a number of features and a very important security fix listed below. It is highly recommended that you upgrade as soon as possible to avoid this vulnerability and you can find out more about the 1.6.5 release here. Join us Wednesdays at 12:00 CT for some more FreeSWITCH fun! This week we have Martin O’Shield from Windy City SDR! And head over to freeswitch.com to learn more about FreeSWITCH support.

Security issues:

A bug allowing for a remotely exploited DoS attack through custom crafted network traffic via JSON has been fixed. We classify this issue as High Severity. A patch was added by Anthony Minessale in commit 4bdca81 to resolve this issue. All versions from 1.4.4 through the previous release are vulnerable. We highly recommend updating to the current release version as soon as possible.
https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2015-7392

New features that were added:

• FS-8543 [mod_conference] Improve mute handling on conference and WebRTC
• FS-8546 [mod_conference][mod_verto] Make original video demo backward compatible with livearray-json-status
• FS-8529 [mod_conference] Added video-floor to personal canvas mode
• FS-8401 [verto_communicator] Added Speaker selection in settings model and video page and fixed model to modal
• FS-8545 [verto_communicator] Improve controls for screen share, fixed a read lock regression, do not allow video floor on a member with a reservation id set, and add missing code to deal with screen share part
• FS-8549 [mod_http_cache] Add support for AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables in S3 profiles
• FS-8547 [core] Add error log into stats to log when quality impacting events begin and end
• FS-8559 [mod_shout] Add “mpga” to the list of supported extensions

Improvements in build system, cross platform support, and packaging:

• FS-8333 [build][Debian] Added mod_hiredis.deb

The following bugs were squashed:

• FS-8537 [mod_lua] Fixed a segfault caused by passing nil to various lua functions
• FS-8527 [mod_conference] Do not send the video of last_video_floor_holder to video_floor_holder if the videos are related
• FS-8542 [verto_communicator] Fixed the tooltips of video controls
• FS-8053 [mod_conference][mod_sofia] Fix for WebRTC’s SDP containing a=sendonly for video, but the client still receiving the video stream
• FS-8553 [config] Include verto_contact into the dial-string in the samples
• FS-8556 [mod_verto] Screen shares are not recoverable so do not try
• FS-8293 [mod_verto] Fixed some regressions where speed test caused excessive downlink bandwidth

The FreeSWITCH 1.4 branch had this week’s previously mentioned security fix and a bug fix back ported as well as the release of 1.4.26. And again, keep in mind that 1.4 is quickly moving toward end of life and won’t be supported any longer except for high level security issues.

• FS-8537 [mod_lua] Fixed a segfault caused by passing nil to various lua functions