A brief overview on the API flow while making an MO Call. The document is a walk through the code flow of a Call from the user interface (DIALER) to the Telecom Service , then to the Telephony Framework into the RIL(Java.)

1. Android MO Call Flow – Code
Overview – ANDROID (N and below)

2. The MAIN components
• The DIALER – UI
• TELECOM FRAMEWORK / SERVICES
• TELEPHONY FRAMEWORK / SERVICES
• RADIO INTERFACE LAYER (RIL)

3. The UI or DIALER
~This is the user interface for making a CALL.
~A Call is transferred from the UI( your dialer) to the Android Framework through
Broadcast Actions.
~These Actions are defined in android source and can be found here :Call Defines
• public static final String ACTION_DIAL = "android.intent.action.DIAL";
• public static final String ACTION_CALL = "android.intent.action.CALL";
• public static final String ACTION_CALL_EMERGENCY = "android.intent.action.CALL_EMERGENCY";
These broadcasts along with bundles containing the user data (dialed
number/information)are received by the Telecom service and further processing of the CALL
happens

4. TELECOM
File : Packages/services/Telecomm/AndroidManifest.xml Telecom Manifest
• The Telecom Framework. (Components: Connection Service and InCallUiService). The telecom service , if you see binds to
ITelscomService :
The Telecom Service receives the Call Intent from the Dialer with different
permissions –

5. TELECOM contd..
• The Call Activity. CallActivity.java
• As we reach here, The received intent is processed (the processing
basically checks if something needs to be restored from the bundle, check
privileges, allow/disallow based on restrictions.
• Finally, sendBroadcastAsUser(intent, UserHandle.OWNER); is called.

6. TELECOM Contd ..
CallReceiver.java
• This is the default broadcast receiver for Incoming and Out Going Calls. Here , as we are discussing about outgoing
calls, let us see how that goes ~

7. TELECOM Contd ..
• CallReceiver Continued :
• -----------------------------The descriptions are sin the code are self-explanatory----------------------------
• The NewOutgoingCallBroadcaster further tranfers the call to Call Manager, after its own processing.Check
out the Class to see what things it takes care of : NewOutgoingCallIntentBroadcaster.java

8. TELECOM Contd ..
• CallsManager.java

9. TELECOM Contd ..
• Call.java
The Create ConnectionProcessor processes/handles the connection logics.

10. TELECOM Contd ..
• CreateConnectionProcessor.java

11. TELECOM Contd ..
• CreateConnectionProcessor.java
• It firstly creates and CallAttemptRecord and collects into its list, then process it by a new
class' function ConnectionServiceWrapper.createConnection().

12. TELECOM Contd ..
• CreateConnectionProcessor.java
/* in this API(attemptNextPhoneAccount), A ConnectionServiceWrapper is used[NEXT
SLIDE]. The logic of creation of this Wrapper class, initialization etc. will be discussed
separately. You are welcome to look into the implementation/code yourself.*/

13. TELECOM Contd ..

14. TELECOM Contd ..
• ConnectionServiceWrapper.java. See the definition of the class
Here is where the IConnectionService is bound. Check the below Function: It is in the ServiceBinder the class
which is the parent class of ConnectionServiceWrapper.

15. TELECOM Contd ..
• ServiceBinder.java
• Let us check the CreateConnection API in detail. A BinderCallBack object [implemented in ServiceBinder ]
is associated with mBinder. What is mBinder?
~ private Binder2 mBinder = new Binder2() / / code in ConnectionServiceWrapper
~Then, mBinder.bind(callback,call) is done so the callback is associated with the call. We will see
the implementation of Binder2 class in a short while. In the onSuccess() of the Callback,
mServiceInterface.createConnection is done which is actually the implementation in the stub.
• Let us check out the important parts of ServiceBinder.java

16. TELECOM Contd ..
Second, the Binder2 Class. As per the code description, It Performs an asynchronous bind to the
Service and executes the specific callback. Let us go step by step with it here –
~ mCallbacks.add(callback); -
~ setBinder(binder); -- > setServiceInterface(binder); //in the child class where we retrieve
IConnnectionnService as interface.
~ ServiceConnection connection = new ServiceBinderConnection(call);
~ mContext.bindService(serviceIntent, connection, bindingFlags);
~ private final class ServiceBinderConnection implements ServiceConnection { …
~ handleFailedConnection(); -- > callback.onSuccess(); // Call back that was bound to.
ServiceConnected(ComponentName..

17. TELECOM Contd ..
• The Actual implmementation of the IConnectionService –
• Check the Constructor of connection Service Wrapper. Look for :
super(ConnectionService.SERVICE_INTERFACE, componentName, context, userHandle);
• Check frameworks/base/telecomm/java/android/telecom/ConnectionService.java
• As I have already pointed out, this service is bound in the Binder2 class of ServiceBinder.java and through
the following call mServiceInterface is obtained.
(Check previous Slides)
setBinder(binder); -- > setServiceInterface(binder); //in the child class where we retrieve
IConnnectionnService as interface.
• So, there it is , Telecom is all set to transfer the call to Telephony now which implements the
ConnectionService.

18. Telephony FW
• Here, the android.telecom.ConnectionService is registered.
This is extended by TelephonyConnectionService.java
From here, Connection onCreateIncomingConnection will call
placeOutgoingConnection() and will transfer the Call to the Target Phone.

19. Telephony FW
*Here is to note that the target phone is made at the boot time based on the NW
TYPE the phone latches to. It can be of type – GSM, CDMA or IMS. The instance of
the PHONE is provided to TelephonyConnectionService with the PhoneFactory Class.
The discussion about creation of Phone object will be left for another day.
TelephonyConnectionService.java

20. Telephony FW
The Phone Call in PHONE.
Let us assume, we have a GSM Phone as our Active Phone. Now, DIAL(..) will
come here.
GSMPhone.java
From GSMPhone , the Call is transferred to the CallTracker, where we have
the RIL Command interfaces implemented, which in turn transfers the Call to
modem through the RIL command interface.

21. Telephony FW
• GsmCallTracker.java
• public CommandsInterface mCM; is associated with each Phone which is
the connection point to RIL.java. You can find and understand it in
PhoneBase.java. The implementation of Commands Interface is in RIL.java

22. Telephony FW(RIL-J)
• Commands Interface Implementation and DIAL and request to RILD through socket. The details are for
another day.
RIL.java

23. Thank You
• So, that was a very brief overview of the flow of APIs for an
Android Outgoing CALL. Going forward we will discuss about the
RIL and the PHONE class hierarchy in a detailed fashion.
• The above slides were based on Android (N) code. There is a
major change in OOS architecture as far as the Radio interface is
concerned. We shall discuss that too in the future.
• Credits : Android Open Source Project.