blob: f1bb109654f7362915013b868c98bbcf77eb371f [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;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080026
Santos Cordon681663d2014-01-30 04:32:15 -080027import com.google.common.base.Preconditions;
28import com.google.common.base.Strings;
Sailesh Nepal810735e2014-03-18 18:15:46 -070029import com.google.common.collect.ImmutableCollection;
30import com.google.common.collect.ImmutableList;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080031import com.google.common.collect.Lists;
Santos Cordon681663d2014-01-30 04:32:15 -080032import com.google.common.collect.Maps;
Santos Cordona56f2762014-03-24 15:55:53 -070033import com.google.common.collect.Sets;
Ben Gilad9f2bed32013-12-12 17:43:26 -080034
Ben Gilad9f2bed32013-12-12 17:43:26 -080035import java.util.List;
Santos Cordon681663d2014-01-30 04:32:15 -080036import java.util.Map;
Santos Cordona56f2762014-03-24 15:55:53 -070037import java.util.Set;
Ben Gilad9f2bed32013-12-12 17:43:26 -080038
Ben Giladdd8c6082013-12-30 14:44:08 -080039/**
40 * Singleton.
41 *
42 * NOTE(gilad): by design most APIs are package private, use the relevant adapter/s to allow
43 * access from other packages specifically refraining from passing the CallsManager instance
44 * beyond the com.android.telecomm package boundary.
45 */
Santos Cordon8e8b8d22013-12-19 14:14:05 -080046public final class CallsManager {
Ben Gilada0d9f752014-02-26 11:49:03 -080047
Santos Cordona56f2762014-03-24 15:55:53 -070048 // TODO(santoscordon): Consider renaming this CallsManagerPlugin.
Sailesh Nepal810735e2014-03-18 18:15:46 -070049 interface CallsManagerListener {
50 void onCallAdded(Call call);
51 void onCallRemoved(Call call);
52 void onCallStateChanged(Call call, CallState oldState, CallState newState);
53 void onIncomingCallAnswered(Call call);
54 void onIncomingCallRejected(Call call);
55 void onForegroundCallChanged(Call oldForegroundCall, Call newForegroundCall);
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070056 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState);
Sailesh Nepal810735e2014-03-18 18:15:46 -070057 }
58
Santos Cordon8e8b8d22013-12-19 14:14:05 -080059 private static final CallsManager INSTANCE = new CallsManager();
Ben Gilad9f2bed32013-12-12 17:43:26 -080060
Santos Cordone3d76ab2014-01-28 17:25:20 -080061 private final Switchboard mSwitchboard;
62
Santos Cordon8e8b8d22013-12-19 14:14:05 -080063 /**
Santos Cordon681663d2014-01-30 04:32:15 -080064 * The main call repository. Keeps an instance of all live calls keyed by call ID. New incoming
65 * and outgoing calls are added to the map and removed when the calls move to the disconnected
66 * state.
67 * TODO(santoscordon): Add new CallId class and use it in place of String.
68 */
69 private final Map<String, Call> mCalls = Maps.newHashMap();
70
71 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -070072 * The call the user is currently interacting with. This is the call that should have audio
73 * focus and be visible in the in-call UI.
Santos Cordon4e9fffe2014-03-04 18:13:41 -080074 */
Sailesh Nepal810735e2014-03-18 18:15:46 -070075 private Call mForegroundCall;
Santos Cordon4e9fffe2014-03-04 18:13:41 -080076
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070077 private final CallAudioManager mCallAudioManager;
Sailesh Nepal810735e2014-03-18 18:15:46 -070078
Santos Cordona56f2762014-03-24 15:55:53 -070079 private final Set<CallsManagerListener> mListeners = Sets.newHashSet();
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070080
Evan Charltonf02e9882014-03-06 12:54:52 -080081 private final List<OutgoingCallValidator> mOutgoingCallValidators = Lists.newArrayList();
Ben Gilad9f2bed32013-12-12 17:43:26 -080082
Evan Charltonf02e9882014-03-06 12:54:52 -080083 private final List<IncomingCallValidator> mIncomingCallValidators = Lists.newArrayList();
Ben Gilad9f2bed32013-12-12 17:43:26 -080084
Santos Cordon8e8b8d22013-12-19 14:14:05 -080085 /**
Ben Gilad8bdaa462014-02-05 12:53:19 -080086 * Initializes the required Telecomm components.
Santos Cordon8e8b8d22013-12-19 14:14:05 -080087 */
88 private CallsManager() {
Santos Cordon6242b132014-02-07 16:24:42 -080089 mSwitchboard = new Switchboard(this);
Santos Cordona56f2762014-03-24 15:55:53 -070090
Sailesh Nepal810735e2014-03-18 18:15:46 -070091 mCallAudioManager = new CallAudioManager();
Santos Cordona56f2762014-03-24 15:55:53 -070092
93 mListeners.add(new CallLogManager(TelecommApp.getInstance()));
94 mListeners.add(new PhoneStateBroadcaster());
95 mListeners.add(new InCallController());
96 mListeners.add(new Ringer(mCallAudioManager));
97 mListeners.add(new RingbackPlayer(this, new InCallTonePlayer.Factory(mCallAudioManager)));
98 mListeners.add(mCallAudioManager);
Santos Cordon8e8b8d22013-12-19 14:14:05 -080099 }
100
Ben Gilada0d9f752014-02-26 11:49:03 -0800101 static CallsManager getInstance() {
102 return INSTANCE;
103 }
104
Sailesh Nepal810735e2014-03-18 18:15:46 -0700105 ImmutableCollection<Call> getCalls() {
106 return ImmutableList.copyOf(mCalls.values());
107 }
108
109 Call getForegroundCall() {
110 return mForegroundCall;
111 }
112
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700113 boolean hasEmergencyCall() {
114 for (Call call : mCalls.values()) {
115 if (call.isEmergencyCall()) {
116 return true;
117 }
118 }
119 return false;
120 }
121
122 CallAudioState getAudioState() {
123 return mCallAudioManager.getAudioState();
124 }
125
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800126 /**
Santos Cordon493e8f22014-02-19 03:15:12 -0800127 * Starts the incoming call sequence by having switchboard gather more information about the
128 * specified call; using the specified call service descriptor. Upon success, execution returns
129 * to {@link #handleSuccessfulIncomingCall} to start the in-call UI.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800130 *
Ben Giladc5b22692014-02-18 20:03:22 -0800131 * @param descriptor The descriptor of the call service to use for this incoming call.
Evan Charltona05805b2014-03-05 08:21:46 -0800132 * @param extras The optional extras Bundle passed with the intent used for the incoming call.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800133 */
Evan Charltona05805b2014-03-05 08:21:46 -0800134 void processIncomingCallIntent(CallServiceDescriptor descriptor, Bundle extras) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800135 Log.d(this, "processIncomingCallIntent");
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800136 // Create a call with no handle. Eventually, switchboard will update the call with
137 // additional information from the call service, but for now we just need one to pass around
138 // with a unique call ID.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700139 Call call = new Call(true /* isIncoming */);
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800140
Evan Charltona05805b2014-03-05 08:21:46 -0800141 mSwitchboard.retrieveIncomingCall(call, descriptor, extras);
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800142 }
143
144 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800145 * Validates the specified call and, upon no objection to connect it, adds the new call to the
146 * list of live calls. Also notifies the in-call app so the user can answer or reject the call.
147 *
148 * @param call The new incoming call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700149 * @param callInfo The details of the call.
Ben Gilada0d9f752014-02-26 11:49:03 -0800150 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700151 void handleSuccessfulIncomingCall(Call call, CallInfo callInfo) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800152 Log.d(this, "handleSuccessfulIncomingCall");
Sailesh Nepal810735e2014-03-18 18:15:46 -0700153 Preconditions.checkState(callInfo.getState() == CallState.RINGING);
Ben Gilada0d9f752014-02-26 11:49:03 -0800154
Sailesh Nepalce704b92014-03-17 18:31:43 -0700155 Uri handle = call.getHandle();
Ben Gilada0d9f752014-02-26 11:49:03 -0800156 ContactInfo contactInfo = call.getContactInfo();
157 for (IncomingCallValidator validator : mIncomingCallValidators) {
158 if (!validator.isValid(handle, contactInfo)) {
159 // TODO(gilad): Consider displaying an error message.
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800160 Log.i(this, "Dropping restricted incoming call");
Ben Gilada0d9f752014-02-26 11:49:03 -0800161 return;
162 }
163 }
164
165 // No objection to accept the incoming call, proceed with potentially connecting it (based
166 // on the user's action, or lack thereof).
Sailesh Nepal810735e2014-03-18 18:15:46 -0700167 call.setHandle(callInfo.getHandle());
168 setCallState(call, callInfo.getState());
Ben Gilada0d9f752014-02-26 11:49:03 -0800169 addCall(call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700170 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800171
Sailesh Nepal810735e2014-03-18 18:15:46 -0700172 /**
173 * Called when an incoming call was not connected.
174 *
175 * @param call The incoming call.
176 */
177 void handleUnsuccessfulIncomingCall(Call call) {
178 setCallState(call, CallState.DISCONNECTED);
Ben Gilada0d9f752014-02-26 11:49:03 -0800179 }
180
181 /**
Yorke Lee33501632014-03-17 19:24:12 -0700182 * Attempts to issue/connect the specified call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800183 *
Yorke Lee33501632014-03-17 19:24:12 -0700184 * @param handle Handle to connect the call with.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800185 * @param contactInfo Information about the entity being called.
Yorke Lee33501632014-03-17 19:24:12 -0700186 * @param gatewayInfo Optional gateway information that can be used to route the call to the
187 * actual dialed handle via a gateway provider. May be null.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800188 */
Yorke Lee33501632014-03-17 19:24:12 -0700189 void placeOutgoingCall(Uri handle, ContactInfo contactInfo, GatewayInfo gatewayInfo) {
Ben Gilad8bdaa462014-02-05 12:53:19 -0800190 for (OutgoingCallValidator validator : mOutgoingCallValidators) {
Ben Gilada0d9f752014-02-26 11:49:03 -0800191 if (!validator.isValid(handle, contactInfo)) {
192 // TODO(gilad): Display an error message.
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800193 Log.i(this, "Dropping restricted outgoing call.");
Ben Gilada0d9f752014-02-26 11:49:03 -0800194 return;
195 }
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800196 }
197
Yorke Lee33501632014-03-17 19:24:12 -0700198 final Uri uriHandle = (gatewayInfo == null) ? handle : gatewayInfo.getGatewayHandle();
199
200 if (gatewayInfo == null) {
201 Log.i(this, "Creating a new outgoing call with handle: %s", Log.pii(uriHandle));
202 } else {
203 Log.i(this, "Creating a new outgoing call with gateway handle: %s, original handle: %s",
204 Log.pii(uriHandle), Log.pii(handle));
205 }
206 Call call = new Call(uriHandle, contactInfo, gatewayInfo, false /*isIncoming*/);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700207 setCallState(call, CallState.DIALING);
208 addCall(call);
Santos Cordonc195e362014-02-11 17:05:31 -0800209 mSwitchboard.placeOutgoingCall(call);
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800210 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800211
212 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700213 * Called when a call service acknowledges that it can place a call.
Santos Cordon681663d2014-01-30 04:32:15 -0800214 *
215 * @param call The new outgoing call.
216 */
217 void handleSuccessfulOutgoingCall(Call call) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700218 Log.v(this, "handleSuccessfulOutgoingCall, %s", call);
Santos Cordon681663d2014-01-30 04:32:15 -0800219 }
220
221 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700222 * Called when an outgoing call was not placed.
Yorke Leef98fb572014-03-05 10:56:55 -0800223 *
Sailesh Nepal810735e2014-03-18 18:15:46 -0700224 * @param call The outgoing call.
225 * @param isAborted True if the call was unsuccessful because it was aborted.
Yorke Leef98fb572014-03-05 10:56:55 -0800226 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700227 void handleUnsuccessfulOutgoingCall(Call call, boolean isAborted) {
228 Log.v(this, "handleAbortedOutgoingCall, call: %s, isAborted: %b", call, isAborted);
229 if (isAborted) {
230 call.abort();
231 setCallState(call, CallState.ABORTED);
232 } else {
233 setCallState(call, CallState.DISCONNECTED);
234 }
235 removeCall(call);
Yorke Leef98fb572014-03-05 10:56:55 -0800236 }
237
238 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800239 * Instructs Telecomm to answer the specified call. Intended to be invoked by the in-call
240 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
241 * the user opting to answer said call.
242 *
243 * @param callId The ID of the call.
244 */
245 void answerCall(String callId) {
Santos Cordon61d0f702014-02-19 02:52:23 -0800246 Call call = mCalls.get(callId);
247 if (call == null) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800248 Log.i(this, "Request to answer a non-existent call %s", callId);
Santos Cordon61d0f702014-02-19 02:52:23 -0800249 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700250 for (CallsManagerListener listener : mListeners) {
251 listener.onIncomingCallAnswered(call);
252 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800253
Santos Cordon61d0f702014-02-19 02:52:23 -0800254 // We do not update the UI until we get confirmation of the answer() through
255 // {@link #markCallAsActive}. However, if we ever change that to look more responsive,
256 // then we need to make sure we add a timeout for the answer() in case the call never
257 // comes out of RINGING.
258 call.answer();
259 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800260 }
261
262 /**
263 * Instructs Telecomm to reject the specified call. Intended to be invoked by the in-call
264 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
265 * the user opting to reject said call.
266 *
267 * @param callId The ID of the call.
268 */
269 void rejectCall(String callId) {
Santos Cordon61d0f702014-02-19 02:52:23 -0800270 Call call = mCalls.get(callId);
271 if (call == null) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800272 Log.i(this, "Request to reject a non-existent call %s", callId);
Santos Cordon61d0f702014-02-19 02:52:23 -0800273 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700274 for (CallsManagerListener listener : mListeners) {
275 listener.onIncomingCallRejected(call);
276 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700277
Santos Cordon61d0f702014-02-19 02:52:23 -0800278 call.reject();
279 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800280 }
281
282 /**
283 * Instructs Telecomm to disconnect the specified call. Intended to be invoked by the
284 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
285 * the user hitting the end-call button.
286 *
287 * @param callId The ID of the call.
288 */
289 void disconnectCall(String callId) {
Santos Cordon049b7b62014-01-30 05:34:26 -0800290 Call call = mCalls.get(callId);
291 if (call == null) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800292 Log.w(this, "Unknown call (%s) asked to disconnect", callId);
Santos Cordon049b7b62014-01-30 05:34:26 -0800293 } else {
294 call.disconnect();
295 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800296 }
Santos Cordon681663d2014-01-30 04:32:15 -0800297
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700298 /**
299 * Instructs Telecomm to put the specified call on hold. Intended to be invoked by the
300 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
301 * the user hitting the hold button during an active call.
302 *
303 * @param callId The ID of the call.
304 */
305 void holdCall(String callId) {
306 Call call = mCalls.get(callId);
307 if (call == null) {
308 Log.w(this, "Unknown call (%s) asked to be put on hold", callId);
309 } else {
310 Log.d(this, "Putting call on hold: (%s)", callId);
311 call.hold();
312 }
313 }
314
315 /**
316 * Instructs Telecomm to release the specified call from hold. Intended to be invoked by
317 * the in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered
318 * by the user hitting the hold button during a held call.
319 *
320 * @param callId The ID of the call
321 */
322 void unholdCall(String callId) {
323 Call call = mCalls.get(callId);
324 if (call == null) {
325 Log.w(this, "Unknown call (%s) asked to be removed from hold", callId);
326 } else {
327 Log.d(this, "Removing call from hold: (%s)", callId);
328 call.unhold();
329 }
330 }
331
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700332 /** Called by the in-call UI to change the mute state. */
333 void mute(boolean shouldMute) {
334 mCallAudioManager.mute(shouldMute);
335 }
336
337 /**
338 * Called by the in-call UI to change the audio route, for example to change from earpiece to
339 * speaker phone.
340 */
341 void setAudioRoute(int route) {
342 mCallAudioManager.setAudioRoute(route);
343 }
344
345 /** Called when the audio state changes. */
346 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState) {
347 Log.v(this, "onAudioStateChanged, audioState: %s -> %s", oldAudioState, newAudioState);
Santos Cordona56f2762014-03-24 15:55:53 -0700348 for (CallsManagerListener listener : mListeners) {
349 listener.onAudioStateChanged(oldAudioState, newAudioState);
350 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700351 }
352
Santos Cordon681663d2014-01-30 04:32:15 -0800353 void markCallAsRinging(String callId) {
354 setCallState(callId, CallState.RINGING);
355 }
356
357 void markCallAsDialing(String callId) {
358 setCallState(callId, CallState.DIALING);
359 }
360
361 void markCallAsActive(String callId) {
362 setCallState(callId, CallState.ACTIVE);
363 }
364
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700365 void markCallAsOnHold(String callId) {
366 setCallState(callId, CallState.ON_HOLD);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700367 }
368
Santos Cordon049b7b62014-01-30 05:34:26 -0800369 /**
370 * Marks the specified call as DISCONNECTED and notifies the in-call app. If this was the last
371 * live call, then also disconnect from the in-call controller.
372 *
373 * @param callId The ID of the call.
374 */
Santos Cordon681663d2014-01-30 04:32:15 -0800375 void markCallAsDisconnected(String callId) {
376 setCallState(callId, CallState.DISCONNECTED);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700377 removeCall(mCalls.remove(callId));
Ben Gilada0d9f752014-02-26 11:49:03 -0800378 }
379
380 /**
Santos Cordon4b2c1192014-03-19 18:15:38 -0700381 * Cleans up any calls currently associated with the specified call service when the
382 * call-service binder disconnects unexpectedly.
383 *
384 * @param callService The call service that disconnected.
385 */
386 void handleCallServiceDeath(CallServiceWrapper callService) {
387 Preconditions.checkNotNull(callService);
388 for (Call call : ImmutableList.copyOf(mCalls.values())) {
389 if (call.getCallService() == callService) {
390 markCallAsDisconnected(call.getId());
391 }
392 }
393 }
394
395 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800396 * Adds the specified call to the main list of live calls.
397 *
398 * @param call The call to add.
399 */
400 private void addCall(Call call) {
401 mCalls.put(call.getId(), call);
Santos Cordona56f2762014-03-24 15:55:53 -0700402 for (CallsManagerListener listener : mListeners) {
403 listener.onCallAdded(call);
404 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700405 updateForegroundCall();
Ben Gilada0d9f752014-02-26 11:49:03 -0800406 }
407
Sailesh Nepal810735e2014-03-18 18:15:46 -0700408 private void removeCall(Call call) {
409 call.clearCallService();
Santos Cordona56f2762014-03-24 15:55:53 -0700410 for (CallsManagerListener listener : mListeners) {
411 listener.onCallRemoved(call);
412 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700413 updateForegroundCall();
Ben Gilada0d9f752014-02-26 11:49:03 -0800414 }
415
416 /**
Santos Cordon1ae2b852014-03-19 03:03:10 -0700417 * Sets the specified state on the specified call.
Santos Cordon681663d2014-01-30 04:32:15 -0800418 *
419 * @param callId The ID of the call to update.
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800420 * @param newState The new state of the call.
Santos Cordon681663d2014-01-30 04:32:15 -0800421 */
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800422 private void setCallState(String callId, CallState newState) {
Santos Cordon681663d2014-01-30 04:32:15 -0800423 Preconditions.checkState(!Strings.isNullOrEmpty(callId));
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800424 Preconditions.checkNotNull(newState);
Santos Cordon681663d2014-01-30 04:32:15 -0800425
426 Call call = mCalls.get(callId);
427 if (call == null) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800428 Log.w(this, "Call %s was not found while attempting to update the state to %s.",
429 callId, newState );
Santos Cordon681663d2014-01-30 04:32:15 -0800430 } else {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700431 setCallState(call, newState);
432 }
433 }
Evan Charlton5c670a92014-03-06 14:58:20 -0800434
Sailesh Nepal810735e2014-03-18 18:15:46 -0700435 /**
Santos Cordon1ae2b852014-03-19 03:03:10 -0700436 * Sets the specified state on the specified call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700437 *
438 * @param call The call.
439 * @param newState The new state of the call.
440 */
441 private void setCallState(Call call, CallState newState) {
442 CallState oldState = call.getState();
443 if (newState != oldState) {
444 // Unfortunately, in the telephony world the radio is king. So if the call notifies
445 // us that the call is in a particular state, we allow it even if it doesn't make
446 // sense (e.g., ACTIVE -> RINGING).
447 // TODO(santoscordon): Consider putting a stop to the above and turning CallState
448 // into a well-defined state machine.
449 // TODO(santoscordon): Define expected state transitions here, and log when an
450 // unexpected transition occurs.
451 call.setState(newState);
452
453 // Only broadcast state change for calls that are being tracked.
454 if (mCalls.containsKey(call.getId())) {
Santos Cordona56f2762014-03-24 15:55:53 -0700455 for (CallsManagerListener listener : mListeners) {
456 listener.onCallStateChanged(call, oldState, newState);
457 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700458 updateForegroundCall();
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800459 }
460 }
461 }
462
463 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700464 * Checks which call should be visible to the user and have audio focus.
Evan Charlton5c670a92014-03-06 14:58:20 -0800465 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700466 private void updateForegroundCall() {
467 Call newForegroundCall = null;
468 for (Call call : mCalls.values()) {
469 // Incoming ringing calls have priority.
470 if (call.getState() == CallState.RINGING) {
471 newForegroundCall = call;
Evan Charlton5c670a92014-03-06 14:58:20 -0800472 break;
Sailesh Nepal810735e2014-03-18 18:15:46 -0700473 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700474 if (call.isAlive()) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700475 newForegroundCall = call;
476 // Don't break in case there's a ringing call that has priority.
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800477 }
478 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800479
Sailesh Nepal810735e2014-03-18 18:15:46 -0700480 if (newForegroundCall != mForegroundCall) {
481 Call oldForegroundCall = mForegroundCall;
482 mForegroundCall = newForegroundCall;
483
Santos Cordona56f2762014-03-24 15:55:53 -0700484 for (CallsManagerListener listener : mListeners) {
485 listener.onForegroundCallChanged(oldForegroundCall, mForegroundCall);
486 }
Santos Cordon681663d2014-01-30 04:32:15 -0800487 }
488 }
Ben Gilad9f2bed32013-12-12 17:43:26 -0800489}