I have created an iOS app using signal private messenger (Signal Messenger). The application supports one to one calls using WebRTC.
Now I have a requirement of adding participants to existing calls.
Is this possible using the existing framework? Or do I have to implement additional code on server/client to support it?
You can find https://github.com/googlecodelabs/webrtc-web/issues/72 discussion with possible way to adapt WebRTC to multiple connections, while in other issue using https://github.com/medooze/media-server is advised. Therefore WebRTC do not offers this feature easily implemented.
Signal-iOS and Signal-Android now have only feature requests for conference calls https://community.signalusers.org/t/conference-calls/870 and https://github.com/signalapp/Signal-iOS/issues/1804
So you can either wait until Signal developers would release that or contribute on the project and deliver that feature.
The concept behind adding participant in the current call is known as renegotiation.
In this peers exchange the session description packet again with each other and negotiate ice candidates.
In order to achieve this in the signal app, you first have to know the flow of single call and make custom messages to flow to renegotiate the same.
Related
In android you are able to interface with the native telecom system.
The Android framework includes the android.telecom package, which contains classes that help you build a calling app according to the telecom framework. Building your app according to the telecom framework provides the following benefits:
Your app interoperates correctly with the native telecom subsystem in the device.
Your app interoperates correctly with other calling apps that also adhere to the framework.
The framework helps your app manage audio and video routing.
The framework helps your app determine whether its calls have focus.
What I personally care about is like accepting and rejecting incoming calls, routing the audio streams of incoming calls, and know when they hung up. The closest thing I have found is IOS' Callkit but it doesn't seem to be as feature rich as Android's telecom library and lacks the features I need.
So far I know I am able to:
Reject calls (by dissallowing the call in reportNewIncomingCall)
Find out when a call has finished (by using the callObserver)
I am still looking for:
Accept calls
Stream audio to my incoming calls
Which library should I use for these two things, are both even possible in IOS?
My use case
I basically want the ability accept a call and then instead of immediately connecting to the user, I want to play an audio stream first, before the user gets notified.
I'm currently upgrading my implementation that uses Twilio IPM to use the new GA release twilio-chat after previously using the twilio-ip-messaging package on npm. There are some disparities between the implementations, but this hasn't really been that much of an issue so far. However it seems that there are some event behaviours that have changed and I struggle to understand why.
Prior to twilio-chat, if I had a client A connected in a browser context, any public channel creation (from another client B, or the server side) would trigger the channelAdded event from twilio. This no longer seems to happen. The new channel is visible on any subsequent getPublicChannelDescriptors call, but I do not receive the event.
Is it possible to opt-in to these events? Or in some other way configure that this should be announced to all connected clients?
I can think of a few workarounds, like a named persistent channel where new channel creation is announced, or some other 'push' mechanism for client A to then refresh its channels list, but all feels a bit dirty when there is already a push mechanism in place that used to effect the same behaviour.
Twilio developer evangelist here.
The channelAdded event for public channels was removed in the Programmable Chat SDKs because of a limitations of how many endpoints can subscribe to a single, global public channels object.
You can receive these events by webhook but you would still need a way to notify the client side of your application. Your suggestion of a persistent channel for this is a good workaround. You could even keep this channel hidden from view and send structured data in the message that would allow you to show the new channel in your interface and request more data about it via the SDK.
If a whole chat channel is too much of a hack, you could also try using Twilio Sync to synchronise a list of active channels between users.
I agree that this does seem like a bit of a hack though. It is possible that all channels will cause the channelAdded event again in the future, but I can't promise anything like that right now, so you will need to workaround it.
Using any of the OpenTok client SDKs, is it possible to call from one client to an other client, and make it look like similar to a "real" phone call?
I understand that a user X and user Y can join the same "room" if they both know the name of the room. But I don't understand how user X can send signals, to notify user Y to join a specific room, how is this done? I want it to work cross platform, i.e, work on iOS, Android devices, and web pages. My use cases are:
- app to browser
- browser to app
- app to app
- browser to browser
Is it possible in all of my use cases? Which are possible?
Is it possible to use OpenTok in a mobile app to show an incoming call even though the app is in the background (like how facebook messager and whats app works)
I've gone trough the tutorials on Tokbox website and successfully got them working, but I can't find a way to let different users notify each other to join a session (neither in a peer-to-peer way, or via a server). How should this be done?
I cannot find that this functionality is provided by another player such a Twilio either.
Thanks in advance,
Let's OpenTok do its job. In other words, use OpenTok to actually start a video session. All these things that you talked can be handled WITHOUT OpenTok, like REST APIs or Websocket or whatever.
I used to work in a similar project. Have a server to coordinate everything (all clients connected, who call who, push notifications, etc).
Whenever A needs to call B, the SERVER will start a "room" and put A and B to talk to each other...
So, don't mix the things. Let your server orchestrate everything and use OpenTok for video. It's designed for this purpose.
My work wants to test their new modems using an iPhone app. We can use a current app or build a brand new one. Third party apps are OK but want to avoid jailbreaking if possible.
We want an app which connects to the network and monitors certain parameters for a set amount of time. We will log attributes from the network and modem. We already know it's possible to test speed, disconnections, reconnection time etc. Some of the parameters we need to track might be more secure or outside Apple's regulations.
These are the responses we are looking for:
Frequency (ie. 2462MHz)
Channel Bandwidth (ie. 20MHz, 40MHz)
Radio Type (ie. 802.11a,b,g,n,ac)
802.11 Deauth Reason code
802.11 Association Status code
How can we track the above attributes using an iOS app?
Are there any apps out there that can track this information? Does iOS have anything for tracking these parameters?
Thanks so much!!
I'm trying to get into a new project, by creating an iOS application. But before I start I would like to understand some points:
is it possible to let an application make a phone call? So what I mean is, assumed we have a phone number and would like to call it. Would it be possible to use an (my) application to call this number?
is it possible to let an application speak during a phone call? So after the application started the call, would it be possible that some predefined statements are said in the call?
is it possible that this application hears, registers and analyses what the other person on the phone line is saying? (Leaving apart the privacy issue, assuming that the other person is willing to do that).
Could you please help me? If my question aren't clear, please tell me, I will try to explain it in another way.
Many Thanks
F.P.
iOS is very restricted in terms of the system behaviors third party applications can influence.
To answer your question bluntly, a third party application could prompt the user to initiate a phone / FaceTime call. Once the call is initiated however, your app would enter a background state and relinquish control to the system. The app would not be able to contribute or read any data related to the system phone / FaceTime call.
iOS 10 introduces a VoIP extension, CallKit, which allows third party apps to use the built in calling UI with a custom protocol. You could implement your own protocol (and host servers for handling the exchange of information) and build an extension to make it feel like a system call. You'd be responsible for all aspects of the custom call protocol and thus reading voices, contributing audio, etc. would all be possible (and up to your implementation).
Outside of iOS 10, you would have to built your own VoIP system and interface entirely from scratch.
For more info on CallKit:
WWDC Enhancing VoIP Apps with CallKit
CallKit Enabled Sample App