blob: d3b22be868da36f25574c96b71e1a3ccad3d35e8 [file] [log] [blame]
Santos Cordon8e8b8d22013-12-19 14:14:05 -08001/*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Ben Gilad9f2bed32013-12-12 17:43:26 -080017package com.android.telecomm;
18
Sailesh Nepalce704b92014-03-17 18:31:43 -070019import android.net.Uri;
Evan Charltona05805b2014-03-05 08:21:46 -080020import android.os.Bundle;
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070021import android.telecomm.CallAudioState;
Sailesh Nepal810735e2014-03-18 18:15:46 -070022import android.telecomm.CallInfo;
Ben Giladc5b22692014-02-18 20:03:22 -080023import android.telecomm.CallServiceDescriptor;
Santos Cordon681663d2014-01-30 04:32:15 -080024import android.telecomm.CallState;
Yorke Lee33501632014-03-17 19:24:12 -070025import android.telecomm.GatewayInfo;
Sailesh Nepal8c85dee2014-04-07 22:21:40 -070026import android.telecomm.InCallCall;
Santos Cordon79ff2bc2014-03-27 15:31:27 -070027import android.telephony.DisconnectCause;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080028
Santos Cordon681663d2014-01-30 04:32:15 -080029import com.google.common.base.Preconditions;
30import com.google.common.base.Strings;
Sailesh Nepal810735e2014-03-18 18:15:46 -070031import com.google.common.collect.ImmutableCollection;
32import com.google.common.collect.ImmutableList;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080033import com.google.common.collect.Lists;
Santos Cordon681663d2014-01-30 04:32:15 -080034import com.google.common.collect.Maps;
Santos Cordona56f2762014-03-24 15:55:53 -070035import com.google.common.collect.Sets;
Ben Gilad9f2bed32013-12-12 17:43:26 -080036
Ben Gilad9f2bed32013-12-12 17:43:26 -080037import java.util.List;
Santos Cordon681663d2014-01-30 04:32:15 -080038import java.util.Map;
Santos Cordona56f2762014-03-24 15:55:53 -070039import java.util.Set;
Ben Gilad9f2bed32013-12-12 17:43:26 -080040
Ben Giladdd8c6082013-12-30 14:44:08 -080041/**
42 * Singleton.
43 *
44 * NOTE(gilad): by design most APIs are package private, use the relevant adapter/s to allow
45 * access from other packages specifically refraining from passing the CallsManager instance
46 * beyond the com.android.telecomm package boundary.
47 */
Santos Cordon8e8b8d22013-12-19 14:14:05 -080048public final class CallsManager {
Ben Gilada0d9f752014-02-26 11:49:03 -080049
Santos Cordona56f2762014-03-24 15:55:53 -070050 // TODO(santoscordon): Consider renaming this CallsManagerPlugin.
Sailesh Nepal810735e2014-03-18 18:15:46 -070051 interface CallsManagerListener {
52 void onCallAdded(Call call);
53 void onCallRemoved(Call call);
54 void onCallStateChanged(Call call, CallState oldState, CallState newState);
Sailesh Nepal8c85dee2014-04-07 22:21:40 -070055 void onCallHandoffHandleChanged(Call call, Uri oldHandle, Uri newHandle);
56 void onCallServiceChanged(
57 Call call,
58 CallServiceWrapper oldCallService,
59 CallServiceWrapper newCallService);
60 void onCallHandoffCallServiceDescriptorChanged(
61 Call call,
62 CallServiceDescriptor oldDescriptor,
63 CallServiceDescriptor newDescriptor);
Sailesh Nepal810735e2014-03-18 18:15:46 -070064 void onIncomingCallAnswered(Call call);
65 void onIncomingCallRejected(Call call);
66 void onForegroundCallChanged(Call oldForegroundCall, Call newForegroundCall);
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070067 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState);
Sailesh Nepal810735e2014-03-18 18:15:46 -070068 }
69
Santos Cordon8e8b8d22013-12-19 14:14:05 -080070 private static final CallsManager INSTANCE = new CallsManager();
Ben Gilad9f2bed32013-12-12 17:43:26 -080071
Santos Cordone3d76ab2014-01-28 17:25:20 -080072 private final Switchboard mSwitchboard;
73
Santos Cordon8e8b8d22013-12-19 14:14:05 -080074 /**
Sailesh Nepale59bb192014-04-01 18:33:59 -070075 * The main call repository. Keeps an instance of all live calls. New incoming and outgoing
76 * calls are added to the map and removed when the calls move to the disconnected state.
Santos Cordon681663d2014-01-30 04:32:15 -080077 */
Sailesh Nepale59bb192014-04-01 18:33:59 -070078 private final Set<Call> mCalls = Sets.newLinkedHashSet();
Santos Cordon681663d2014-01-30 04:32:15 -080079
80 /**
Sailesh Nepal84fa5f82014-04-02 11:01:11 -070081 * Set of new calls created to perform a handoff. The calls are added when handoff is initiated
82 * and removed when hadnoff is complete.
83 */
84 private final Set<Call> mPendingHandoffCalls = Sets.newLinkedHashSet();
85
86 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -070087 * The call the user is currently interacting with. This is the call that should have audio
88 * focus and be visible in the in-call UI.
Santos Cordon4e9fffe2014-03-04 18:13:41 -080089 */
Sailesh Nepal810735e2014-03-18 18:15:46 -070090 private Call mForegroundCall;
Santos Cordon4e9fffe2014-03-04 18:13:41 -080091
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070092 private final CallAudioManager mCallAudioManager;
Sailesh Nepal810735e2014-03-18 18:15:46 -070093
Santos Cordona56f2762014-03-24 15:55:53 -070094 private final Set<CallsManagerListener> mListeners = Sets.newHashSet();
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070095
Evan Charltonf02e9882014-03-06 12:54:52 -080096 private final List<OutgoingCallValidator> mOutgoingCallValidators = Lists.newArrayList();
Ben Gilad9f2bed32013-12-12 17:43:26 -080097
Evan Charltonf02e9882014-03-06 12:54:52 -080098 private final List<IncomingCallValidator> mIncomingCallValidators = Lists.newArrayList();
Ben Gilad9f2bed32013-12-12 17:43:26 -080099
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800100 /**
Ben Gilad8bdaa462014-02-05 12:53:19 -0800101 * Initializes the required Telecomm components.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800102 */
103 private CallsManager() {
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700104 TelecommApp app = TelecommApp.getInstance();
Santos Cordona56f2762014-03-24 15:55:53 -0700105
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700106 mSwitchboard = new Switchboard(this);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700107 mCallAudioManager = new CallAudioManager();
Santos Cordona56f2762014-03-24 15:55:53 -0700108
Santos Cordonc7b8eba2014-04-01 15:26:28 -0700109 InCallTonePlayer.Factory playerFactory = new InCallTonePlayer.Factory(mCallAudioManager);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700110 mListeners.add(new CallLogManager(app));
Santos Cordona56f2762014-03-24 15:55:53 -0700111 mListeners.add(new PhoneStateBroadcaster());
112 mListeners.add(new InCallController());
113 mListeners.add(new Ringer(mCallAudioManager));
Santos Cordonc7b8eba2014-04-01 15:26:28 -0700114 mListeners.add(new RingbackPlayer(this, playerFactory));
115 mListeners.add(new InCallToneMonitor(playerFactory, this));
Santos Cordona56f2762014-03-24 15:55:53 -0700116 mListeners.add(mCallAudioManager);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700117 mListeners.add(app.getMissedCallNotifier());
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800118 }
119
Ben Gilada0d9f752014-02-26 11:49:03 -0800120 static CallsManager getInstance() {
121 return INSTANCE;
122 }
123
Sailesh Nepal810735e2014-03-18 18:15:46 -0700124 ImmutableCollection<Call> getCalls() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700125 return ImmutableList.copyOf(mCalls);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700126 }
127
128 Call getForegroundCall() {
129 return mForegroundCall;
130 }
131
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700132 boolean hasEmergencyCall() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700133 for (Call call : mCalls) {
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700134 if (call.isEmergencyCall()) {
135 return true;
136 }
137 }
138 return false;
139 }
140
141 CallAudioState getAudioState() {
142 return mCallAudioManager.getAudioState();
143 }
144
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800145 /**
Santos Cordon493e8f22014-02-19 03:15:12 -0800146 * Starts the incoming call sequence by having switchboard gather more information about the
147 * specified call; using the specified call service descriptor. Upon success, execution returns
148 * to {@link #handleSuccessfulIncomingCall} to start the in-call UI.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800149 *
Ben Giladc5b22692014-02-18 20:03:22 -0800150 * @param descriptor The descriptor of the call service to use for this incoming call.
Evan Charltona05805b2014-03-05 08:21:46 -0800151 * @param extras The optional extras Bundle passed with the intent used for the incoming call.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800152 */
Evan Charltona05805b2014-03-05 08:21:46 -0800153 void processIncomingCallIntent(CallServiceDescriptor descriptor, Bundle extras) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800154 Log.d(this, "processIncomingCallIntent");
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800155 // Create a call with no handle. Eventually, switchboard will update the call with
Sailesh Nepale59bb192014-04-01 18:33:59 -0700156 // additional information from the call service, but for now we just need one to pass
157 // around.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700158 Call call = new Call(true /* isIncoming */);
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800159
Evan Charltona05805b2014-03-05 08:21:46 -0800160 mSwitchboard.retrieveIncomingCall(call, descriptor, extras);
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800161 }
162
163 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800164 * Validates the specified call and, upon no objection to connect it, adds the new call to the
165 * list of live calls. Also notifies the in-call app so the user can answer or reject the call.
166 *
167 * @param call The new incoming call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700168 * @param callInfo The details of the call.
Ben Gilada0d9f752014-02-26 11:49:03 -0800169 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700170 void handleSuccessfulIncomingCall(Call call, CallInfo callInfo) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800171 Log.d(this, "handleSuccessfulIncomingCall");
Sailesh Nepal810735e2014-03-18 18:15:46 -0700172 Preconditions.checkState(callInfo.getState() == CallState.RINGING);
Ben Gilada0d9f752014-02-26 11:49:03 -0800173
Sailesh Nepalce704b92014-03-17 18:31:43 -0700174 Uri handle = call.getHandle();
Ben Gilada0d9f752014-02-26 11:49:03 -0800175 ContactInfo contactInfo = call.getContactInfo();
176 for (IncomingCallValidator validator : mIncomingCallValidators) {
177 if (!validator.isValid(handle, contactInfo)) {
178 // TODO(gilad): Consider displaying an error message.
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800179 Log.i(this, "Dropping restricted incoming call");
Ben Gilada0d9f752014-02-26 11:49:03 -0800180 return;
181 }
182 }
183
184 // No objection to accept the incoming call, proceed with potentially connecting it (based
185 // on the user's action, or lack thereof).
Sailesh Nepal810735e2014-03-18 18:15:46 -0700186 call.setHandle(callInfo.getHandle());
187 setCallState(call, callInfo.getState());
Ben Gilada0d9f752014-02-26 11:49:03 -0800188 addCall(call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700189 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800190
Sailesh Nepal810735e2014-03-18 18:15:46 -0700191 /**
192 * Called when an incoming call was not connected.
193 *
194 * @param call The incoming call.
195 */
196 void handleUnsuccessfulIncomingCall(Call call) {
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700197 // Incoming calls are not added unless they are successful. We set the state and disconnect
198 // cause just as a matter of good bookkeeping. We do not use the specific methods for
199 // setting those values so that we do not trigger CallsManagerListener events.
200 // TODO: Needs more specific disconnect error for this case.
201 call.setDisconnectCause(DisconnectCause.ERROR_UNSPECIFIED, null);
202 call.setState(CallState.DISCONNECTED);
Ben Gilada0d9f752014-02-26 11:49:03 -0800203 }
204
205 /**
Yorke Lee33501632014-03-17 19:24:12 -0700206 * Attempts to issue/connect the specified call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800207 *
Yorke Lee33501632014-03-17 19:24:12 -0700208 * @param handle Handle to connect the call with.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800209 * @param contactInfo Information about the entity being called.
Yorke Lee33501632014-03-17 19:24:12 -0700210 * @param gatewayInfo Optional gateway information that can be used to route the call to the
Santos Cordon5b7b9b32014-03-26 14:00:22 -0700211 * actual dialed handle via a gateway provider. May be null.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800212 */
Yorke Lee33501632014-03-17 19:24:12 -0700213 void placeOutgoingCall(Uri handle, ContactInfo contactInfo, GatewayInfo gatewayInfo) {
Ben Gilad8bdaa462014-02-05 12:53:19 -0800214 for (OutgoingCallValidator validator : mOutgoingCallValidators) {
Ben Gilada0d9f752014-02-26 11:49:03 -0800215 if (!validator.isValid(handle, contactInfo)) {
216 // TODO(gilad): Display an error message.
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800217 Log.i(this, "Dropping restricted outgoing call.");
Ben Gilada0d9f752014-02-26 11:49:03 -0800218 return;
219 }
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800220 }
221
Yorke Lee33501632014-03-17 19:24:12 -0700222 final Uri uriHandle = (gatewayInfo == null) ? handle : gatewayInfo.getGatewayHandle();
223
224 if (gatewayInfo == null) {
225 Log.i(this, "Creating a new outgoing call with handle: %s", Log.pii(uriHandle));
226 } else {
227 Log.i(this, "Creating a new outgoing call with gateway handle: %s, original handle: %s",
228 Log.pii(uriHandle), Log.pii(handle));
229 }
Santos Cordon5b7b9b32014-03-26 14:00:22 -0700230 Call call = new Call(uriHandle, contactInfo, gatewayInfo, false /* isIncoming */);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700231 setCallState(call, CallState.DIALING);
232 addCall(call);
Santos Cordonc195e362014-02-11 17:05:31 -0800233 mSwitchboard.placeOutgoingCall(call);
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800234 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800235
236 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700237 * Called when a call service acknowledges that it can place a call.
Santos Cordon681663d2014-01-30 04:32:15 -0800238 *
239 * @param call The new outgoing call.
240 */
241 void handleSuccessfulOutgoingCall(Call call) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700242 Log.v(this, "handleSuccessfulOutgoingCall, %s", call);
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700243 if (mCalls.contains(call)) {
244 // The call's CallService has been updated.
245 for (CallsManagerListener listener : mListeners) {
246 listener.onCallServiceChanged(call, null, call.getCallService());
247 }
248 } else if (mPendingHandoffCalls.contains(call)) {
Sailesh Nepal4857f472014-04-07 22:26:27 -0700249 updateHandoffCallServiceDescriptor(call.getOriginalCall(),
250 call.getCallService().getDescriptor());
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700251 }
Santos Cordon681663d2014-01-30 04:32:15 -0800252 }
253
254 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700255 * Called when an outgoing call was not placed.
Yorke Leef98fb572014-03-05 10:56:55 -0800256 *
Sailesh Nepal810735e2014-03-18 18:15:46 -0700257 * @param call The outgoing call.
258 * @param isAborted True if the call was unsuccessful because it was aborted.
Yorke Leef98fb572014-03-05 10:56:55 -0800259 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700260 void handleUnsuccessfulOutgoingCall(Call call, boolean isAborted) {
261 Log.v(this, "handleAbortedOutgoingCall, call: %s, isAborted: %b", call, isAborted);
262 if (isAborted) {
263 call.abort();
264 setCallState(call, CallState.ABORTED);
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700265 removeCall(call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700266 } else {
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700267 // TODO: Replace disconnect cause with more specific disconnect causes.
Sailesh Nepale59bb192014-04-01 18:33:59 -0700268 markCallAsDisconnected(call, DisconnectCause.ERROR_UNSPECIFIED, null);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700269 }
Yorke Leef98fb572014-03-05 10:56:55 -0800270 }
271
272 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800273 * Instructs Telecomm to answer the specified call. Intended to be invoked by the in-call
274 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
275 * the user opting to answer said call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800276 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700277 void answerCall(Call call) {
278 if (!mCalls.contains(call)) {
279 Log.i(this, "Request to answer a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800280 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700281 for (CallsManagerListener listener : mListeners) {
282 listener.onIncomingCallAnswered(call);
283 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800284
Santos Cordon61d0f702014-02-19 02:52:23 -0800285 // We do not update the UI until we get confirmation of the answer() through
Sailesh Nepale59bb192014-04-01 18:33:59 -0700286 // {@link #markCallAsActive}.
Santos Cordon61d0f702014-02-19 02:52:23 -0800287 call.answer();
288 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800289 }
290
291 /**
292 * Instructs Telecomm to reject the specified call. Intended to be invoked by the in-call
293 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
294 * the user opting to reject said call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800295 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700296 void rejectCall(Call call) {
297 if (!mCalls.contains(call)) {
298 Log.i(this, "Request to reject a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800299 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700300 for (CallsManagerListener listener : mListeners) {
301 listener.onIncomingCallRejected(call);
302 }
Santos Cordon61d0f702014-02-19 02:52:23 -0800303 call.reject();
304 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800305 }
306
307 /**
Ihab Awad74549ec2014-03-10 15:33:25 -0700308 * Instructs Telecomm to play the specified DTMF tone within the specified call.
309 *
Ihab Awad74549ec2014-03-10 15:33:25 -0700310 * @param digit The DTMF digit to play.
311 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700312 void playDtmfTone(Call call, char digit) {
313 if (!mCalls.contains(call)) {
314 Log.i(this, "Request to play DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700315 } else {
316 call.playDtmfTone(digit);
317 }
318 }
319
320 /**
321 * Instructs Telecomm to stop the currently playing DTMF tone, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700322 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700323 void stopDtmfTone(Call call) {
324 if (!mCalls.contains(call)) {
325 Log.i(this, "Request to stop DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700326 } else {
327 call.stopDtmfTone();
328 }
329 }
330
331 /**
332 * Instructs Telecomm to continue the current post-dial DTMF string, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700333 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700334 void postDialContinue(Call call) {
335 if (!mCalls.contains(call)) {
336 Log.i(this, "Request to continue post-dial string in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700337 } else {
338 // TODO(ihab): Implement this from this level on downwards
339 // call.postDialContinue();
340 // Must play tones locally -- see DTMFTonePlayer.java in Telephony
341 }
342 }
343
344 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800345 * Instructs Telecomm to disconnect the specified call. Intended to be invoked by the
346 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
347 * the user hitting the end-call button.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800348 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700349 void disconnectCall(Call call) {
350 if (!mCalls.contains(call)) {
351 Log.w(this, "Unknown call (%s) asked to disconnect", call);
Santos Cordon049b7b62014-01-30 05:34:26 -0800352 } else {
353 call.disconnect();
354 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800355 }
Santos Cordon681663d2014-01-30 04:32:15 -0800356
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700357 /**
358 * Instructs Telecomm to put the specified call on hold. Intended to be invoked by the
359 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
360 * the user hitting the hold button during an active call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700361 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700362 void holdCall(Call call) {
363 if (!mCalls.contains(call)) {
364 Log.w(this, "Unknown call (%s) asked to be put on hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700365 } else {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700366 Log.d(this, "Putting call on hold: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700367 call.hold();
368 }
369 }
370
371 /**
372 * Instructs Telecomm to release the specified call from hold. Intended to be invoked by
373 * the in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered
374 * by the user hitting the hold button during a held call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700375 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700376 void unholdCall(Call call) {
377 if (!mCalls.contains(call)) {
378 Log.w(this, "Unknown call (%s) asked to be removed from hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700379 } else {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700380 Log.d(this, "Removing call from hold: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700381 call.unhold();
382 }
383 }
384
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700385 /** Called by the in-call UI to change the mute state. */
386 void mute(boolean shouldMute) {
387 mCallAudioManager.mute(shouldMute);
388 }
389
390 /**
391 * Called by the in-call UI to change the audio route, for example to change from earpiece to
392 * speaker phone.
393 */
394 void setAudioRoute(int route) {
395 mCallAudioManager.setAudioRoute(route);
396 }
397
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700398 void startHandoffForCall(Call originalCall) {
399 if (!mCalls.contains(originalCall)) {
400 Log.w(this, "Unknown call %s asked to be handed off", originalCall);
401 return;
402 }
403
404 for (Call handoffCall : mPendingHandoffCalls) {
405 if (handoffCall.getOriginalCall() == originalCall) {
406 Log.w(this, "Call %s is already being handed off, skipping", originalCall);
407 return;
408 }
409 }
410
411 // Create a new call to be placed in the background. If handoff is successful then the
412 // original call will live on but its state will be updated to the new call's state. In
413 // particular the original call's call service will be updated to the new call's call
414 // service.
415 Call tempCall = new Call(originalCall.getHandoffHandle(), originalCall.getContactInfo(),
416 originalCall.getGatewayInfo(), false);
417 tempCall.setOriginalCall(originalCall);
418 tempCall.setExtras(originalCall.getExtras());
419 tempCall.setCallServiceSelector(originalCall.getCallServiceSelector());
420 mPendingHandoffCalls.add(tempCall);
421 Log.d(this, "Placing handoff call");
422 mSwitchboard.placeOutgoingCall(tempCall);
423 }
424
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700425 /** Called when the audio state changes. */
426 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState) {
427 Log.v(this, "onAudioStateChanged, audioState: %s -> %s", oldAudioState, newAudioState);
Santos Cordona56f2762014-03-24 15:55:53 -0700428 for (CallsManagerListener listener : mListeners) {
429 listener.onAudioStateChanged(oldAudioState, newAudioState);
430 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700431 }
432
Sailesh Nepale59bb192014-04-01 18:33:59 -0700433 void markCallAsRinging(Call call) {
434 setCallState(call, CallState.RINGING);
Santos Cordon681663d2014-01-30 04:32:15 -0800435 }
436
Sailesh Nepale59bb192014-04-01 18:33:59 -0700437 void markCallAsDialing(Call call) {
438 setCallState(call, CallState.DIALING);
Santos Cordon681663d2014-01-30 04:32:15 -0800439 }
440
Sailesh Nepale59bb192014-04-01 18:33:59 -0700441 void markCallAsActive(Call call) {
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700442 if (call.getConnectTimeMillis() == 0) {
443 call.setConnectTimeMillis(System.currentTimeMillis());
444 }
Sailesh Nepale59bb192014-04-01 18:33:59 -0700445 setCallState(call, CallState.ACTIVE);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700446
447 if (mPendingHandoffCalls.contains(call)) {
Sailesh Nepal4857f472014-04-07 22:26:27 -0700448 completeHandoff(call, true);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700449 }
Santos Cordon681663d2014-01-30 04:32:15 -0800450 }
451
Sailesh Nepale59bb192014-04-01 18:33:59 -0700452 void markCallAsOnHold(Call call) {
453 setCallState(call, CallState.ON_HOLD);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700454 }
455
Santos Cordon049b7b62014-01-30 05:34:26 -0800456 /**
457 * Marks the specified call as DISCONNECTED and notifies the in-call app. If this was the last
458 * live call, then also disconnect from the in-call controller.
459 *
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700460 * @param disconnectCause The disconnect reason, see {@link android.telephony.DisconnectCause}.
461 * @param disconnectMessage Optional call-service-provided message about the disconnect.
Santos Cordon049b7b62014-01-30 05:34:26 -0800462 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700463 void markCallAsDisconnected(Call call, int disconnectCause, String disconnectMessage) {
464 call.setDisconnectCause(disconnectCause, disconnectMessage);
465 setCallState(call, CallState.DISCONNECTED);
Sailesh Nepal4857f472014-04-07 22:26:27 -0700466
467 // Only remove the call if handoff is not pending.
468 if (call.getHandoffCallServiceDescriptor() == null) {
469 removeCall(call);
470 }
Ben Gilada0d9f752014-02-26 11:49:03 -0800471 }
472
Sailesh Nepal6ab6fb72014-04-01 20:03:19 -0700473 void setHandoffInfo(Call call, Uri handle, Bundle extras) {
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700474 if (!mCalls.contains(call)) {
475 Log.w(this, "Unknown call (%s) asked to set handoff info", call);
476 return;
477 }
478
479 if (extras == null) {
480 call.setExtras(Bundle.EMPTY);
481 } else {
482 call.setExtras(extras);
483 }
484
485 Uri oldHandle = call.getHandoffHandle();
486 Log.v(this, "set handoff handle %s -> %s, for call: %s", oldHandle, handle, call);
487 if (!areUriEqual(oldHandle, handle)) {
488 call.setHandoffHandle(handle);
489 for (CallsManagerListener listener : mListeners) {
490 listener.onCallHandoffHandleChanged(call, oldHandle, handle);
491 }
492 }
Sailesh Nepal6ab6fb72014-04-01 20:03:19 -0700493 }
494
Ben Gilada0d9f752014-02-26 11:49:03 -0800495 /**
Santos Cordon4b2c1192014-03-19 18:15:38 -0700496 * Cleans up any calls currently associated with the specified call service when the
497 * call-service binder disconnects unexpectedly.
498 *
499 * @param callService The call service that disconnected.
500 */
501 void handleCallServiceDeath(CallServiceWrapper callService) {
502 Preconditions.checkNotNull(callService);
Sailesh Nepale59bb192014-04-01 18:33:59 -0700503 for (Call call : ImmutableList.copyOf(mCalls)) {
Santos Cordon4b2c1192014-03-19 18:15:38 -0700504 if (call.getCallService() == callService) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700505 markCallAsDisconnected(call, DisconnectCause.ERROR_UNSPECIFIED, null);
Santos Cordon4b2c1192014-03-19 18:15:38 -0700506 }
507 }
508 }
509
510 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800511 * Adds the specified call to the main list of live calls.
512 *
513 * @param call The call to add.
514 */
515 private void addCall(Call call) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700516 mCalls.add(call);
Santos Cordona56f2762014-03-24 15:55:53 -0700517 for (CallsManagerListener listener : mListeners) {
518 listener.onCallAdded(call);
519 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700520 updateForegroundCall();
Ben Gilada0d9f752014-02-26 11:49:03 -0800521 }
522
Sailesh Nepal810735e2014-03-18 18:15:46 -0700523 private void removeCall(Call call) {
Sailesh Nepal4857f472014-04-07 22:26:27 -0700524 // If a handoff is pending then the original call shouldn't be removed.
525 Preconditions.checkState(call.getHandoffCallServiceDescriptor() == null);
526
Sailesh Nepal810735e2014-03-18 18:15:46 -0700527 call.clearCallService();
Sailesh Nepale59bb192014-04-01 18:33:59 -0700528 call.clearCallServiceSelector();
529
530 boolean shouldNotify = false;
531 if (mCalls.contains(call)) {
532 mCalls.remove(call);
533 shouldNotify = true;
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700534 } else if (mPendingHandoffCalls.contains(call)) {
Sailesh Nepal4857f472014-04-07 22:26:27 -0700535 Log.v(this, "removeCall, marking handoff call as failed");
536 completeHandoff(call, false);
Santos Cordona56f2762014-03-24 15:55:53 -0700537 }
Ben Gilada0d9f752014-02-26 11:49:03 -0800538
Sailesh Nepale59bb192014-04-01 18:33:59 -0700539 // Only broadcast changes for calls that are being tracked.
540 if (shouldNotify) {
541 for (CallsManagerListener listener : mListeners) {
542 listener.onCallRemoved(call);
543 }
544 updateForegroundCall();
Sailesh Nepal810735e2014-03-18 18:15:46 -0700545 }
546 }
Evan Charlton5c670a92014-03-06 14:58:20 -0800547
Sailesh Nepal810735e2014-03-18 18:15:46 -0700548 /**
Santos Cordon1ae2b852014-03-19 03:03:10 -0700549 * Sets the specified state on the specified call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700550 *
551 * @param call The call.
552 * @param newState The new state of the call.
553 */
554 private void setCallState(Call call, CallState newState) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700555 Preconditions.checkNotNull(newState);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700556 CallState oldState = call.getState();
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700557 Log.i(this, "setCallState %s -> %s, call: %s", oldState, newState, call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700558 if (newState != oldState) {
559 // Unfortunately, in the telephony world the radio is king. So if the call notifies
560 // us that the call is in a particular state, we allow it even if it doesn't make
561 // sense (e.g., ACTIVE -> RINGING).
562 // TODO(santoscordon): Consider putting a stop to the above and turning CallState
563 // into a well-defined state machine.
564 // TODO(santoscordon): Define expected state transitions here, and log when an
565 // unexpected transition occurs.
566 call.setState(newState);
567
568 // Only broadcast state change for calls that are being tracked.
Sailesh Nepale59bb192014-04-01 18:33:59 -0700569 if (mCalls.contains(call)) {
Santos Cordona56f2762014-03-24 15:55:53 -0700570 for (CallsManagerListener listener : mListeners) {
571 listener.onCallStateChanged(call, oldState, newState);
572 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700573 updateForegroundCall();
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800574 }
575 }
576 }
577
578 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700579 * Checks which call should be visible to the user and have audio focus.
Evan Charlton5c670a92014-03-06 14:58:20 -0800580 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700581 private void updateForegroundCall() {
582 Call newForegroundCall = null;
Sailesh Nepale59bb192014-04-01 18:33:59 -0700583 for (Call call : mCalls) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700584 // Incoming ringing calls have priority.
585 if (call.getState() == CallState.RINGING) {
586 newForegroundCall = call;
Evan Charlton5c670a92014-03-06 14:58:20 -0800587 break;
Sailesh Nepal810735e2014-03-18 18:15:46 -0700588 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700589 if (call.isAlive()) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700590 newForegroundCall = call;
591 // Don't break in case there's a ringing call that has priority.
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800592 }
593 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800594
Sailesh Nepal810735e2014-03-18 18:15:46 -0700595 if (newForegroundCall != mForegroundCall) {
596 Call oldForegroundCall = mForegroundCall;
597 mForegroundCall = newForegroundCall;
598
Santos Cordona56f2762014-03-24 15:55:53 -0700599 for (CallsManagerListener listener : mListeners) {
600 listener.onForegroundCallChanged(oldForegroundCall, mForegroundCall);
601 }
Santos Cordon681663d2014-01-30 04:32:15 -0800602 }
603 }
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700604
Sailesh Nepal4857f472014-04-07 22:26:27 -0700605 private void completeHandoff(Call handoffCall, boolean wasSuccessful) {
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700606 Call originalCall = handoffCall.getOriginalCall();
Sailesh Nepal4857f472014-04-07 22:26:27 -0700607 Log.v(this, "complete handoff, %s -> %s, wasSuccessful: %b", handoffCall, originalCall,
608 wasSuccessful);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700609
Sailesh Nepal4857f472014-04-07 22:26:27 -0700610 // Remove the transient handoff call object (don't disconnect because the call could still
611 // be live).
612 mPendingHandoffCalls.remove(handoffCall);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700613
Sailesh Nepal4857f472014-04-07 22:26:27 -0700614 if (wasSuccessful) {
615 // Disconnect.
616 originalCall.disconnect();
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700617
Sailesh Nepal4857f472014-04-07 22:26:27 -0700618 // Synchronize.
619 originalCall.setCallService(handoffCall.getCallService(), handoffCall);
620 setCallState(originalCall, handoffCall.getState());
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700621
Sailesh Nepal4857f472014-04-07 22:26:27 -0700622 // Force the foreground call changed notification to be sent.
623 for (CallsManagerListener listener : mListeners) {
624 listener.onForegroundCallChanged(mForegroundCall, mForegroundCall);
625 }
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700626
Sailesh Nepal4857f472014-04-07 22:26:27 -0700627 updateHandoffCallServiceDescriptor(originalCall, null);
628 } else {
629 updateHandoffCallServiceDescriptor(originalCall, null);
630 if (originalCall.getState() == CallState.DISCONNECTED ||
631 originalCall.getState() == CallState.ABORTED) {
632 removeCall(originalCall);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700633 }
634 }
635 }
636
Sailesh Nepal4857f472014-04-07 22:26:27 -0700637 private void updateHandoffCallServiceDescriptor(
638 Call originalCall,
639 CallServiceDescriptor newDescriptor) {
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700640 CallServiceDescriptor oldDescriptor = originalCall.getHandoffCallServiceDescriptor();
Sailesh Nepal4857f472014-04-07 22:26:27 -0700641 Log.v(this, "updateHandoffCallServiceDescriptor, call: %s, pending descriptor: %s -> %s",
642 originalCall, oldDescriptor, newDescriptor);
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700643
644 if (!areDescriptorsEqual(oldDescriptor, newDescriptor)) {
645 originalCall.setHandoffCallServiceDescriptor(newDescriptor);
646 for (CallsManagerListener listener : mListeners) {
647 listener.onCallHandoffCallServiceDescriptorChanged(originalCall, oldDescriptor,
648 newDescriptor);
649 }
650 }
651 }
652
653 private static boolean areDescriptorsEqual(
654 CallServiceDescriptor descriptor1,
655 CallServiceDescriptor descriptor2) {
656 if (descriptor1 == null) {
657 return descriptor2 == null;
658 }
659 return descriptor1.equals(descriptor2);
660 }
661
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700662 private static boolean areUriEqual(Uri handle1, Uri handle2) {
663 if (handle1 == null) {
664 return handle2 == null;
665 }
666 return handle1.equals(handle2);
667 }
Ben Gilad9f2bed32013-12-12 17:43:26 -0800668}