blob: c2af4444a008fb7ba7720dfeacae059213057f87 [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;
Santos Cordon681663d2014-01-30 04:32:15 -080022import android.telecomm.CallState;
Yorke Lee33501632014-03-17 19:24:12 -070023import android.telecomm.GatewayInfo;
Evan Charlton89176372014-07-19 18:23:09 -070024import android.telecomm.PhoneAccountHandle;
Santos Cordon79ff2bc2014-03-27 15:31:27 -070025import android.telephony.DisconnectCause;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080026
Santos Cordon681663d2014-01-30 04:32:15 -080027import com.google.common.base.Preconditions;
Sailesh Nepal810735e2014-03-18 18:15:46 -070028import com.google.common.collect.ImmutableCollection;
29import com.google.common.collect.ImmutableList;
Ben Gilad9f2bed32013-12-12 17:43:26 -080030
Santos Cordonf3671a62014-05-29 21:51:53 -070031import java.util.HashSet;
Santos Cordon7cdb9092014-07-24 21:33:33 -070032import java.util.List;
Santos Cordona56f2762014-03-24 15:55:53 -070033import java.util.Set;
Santos Cordon626697a2014-07-10 22:36:37 -070034import java.util.concurrent.CopyOnWriteArraySet;
Ben Gilad9f2bed32013-12-12 17:43:26 -080035
Ben Giladdd8c6082013-12-30 14:44:08 -080036/**
37 * Singleton.
38 *
39 * NOTE(gilad): by design most APIs are package private, use the relevant adapter/s to allow
40 * access from other packages specifically refraining from passing the CallsManager instance
41 * beyond the com.android.telecomm package boundary.
42 */
Santos Cordon64c7e962014-07-02 15:15:27 -070043public final class CallsManager extends Call.ListenerBase {
Ben Gilada0d9f752014-02-26 11:49:03 -080044
Santos Cordondf399862014-08-06 04:39:15 -070045 // TODO: Consider renaming this CallsManagerPlugin.
Sailesh Nepal810735e2014-03-18 18:15:46 -070046 interface CallsManagerListener {
47 void onCallAdded(Call call);
48 void onCallRemoved(Call call);
49 void onCallStateChanged(Call call, CallState oldState, CallState newState);
Sailesh Nepalc92c4362014-07-04 18:33:21 -070050 void onConnectionServiceChanged(
Sailesh Nepal8c85dee2014-04-07 22:21:40 -070051 Call call,
Sailesh Nepalc92c4362014-07-04 18:33:21 -070052 ConnectionServiceWrapper oldService,
53 ConnectionServiceWrapper newService);
Sailesh Nepal810735e2014-03-18 18:15:46 -070054 void onIncomingCallAnswered(Call call);
Ihab Awadff7493a2014-06-10 13:47:44 -070055 void onIncomingCallRejected(Call call, boolean rejectWithMessage, String textMessage);
Sailesh Nepal810735e2014-03-18 18:15:46 -070056 void onForegroundCallChanged(Call oldForegroundCall, Call newForegroundCall);
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070057 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState);
Ihab Awadcb387ac2014-05-28 16:49:38 -070058 void onRequestingRingback(Call call, boolean ringback);
Santos Cordona1610702014-06-04 20:22:56 -070059 void onIsConferencedChanged(Call call);
Sailesh Nepal7e669572014-07-08 21:29:12 -070060 void onAudioModeIsVoipChanged(Call call);
Andrew Lee4a796602014-07-11 17:23:03 -070061 void onVideoStateChanged(Call call);
Sailesh Nepal810735e2014-03-18 18:15:46 -070062 }
63
Santos Cordon8e8b8d22013-12-19 14:14:05 -080064 private static final CallsManager INSTANCE = new CallsManager();
Ben Gilad9f2bed32013-12-12 17:43:26 -080065
Santos Cordon8e8b8d22013-12-19 14:14:05 -080066 /**
Sailesh Nepale59bb192014-04-01 18:33:59 -070067 * The main call repository. Keeps an instance of all live calls. New incoming and outgoing
68 * calls are added to the map and removed when the calls move to the disconnected state.
Santos Cordon681663d2014-01-30 04:32:15 -080069 */
Santos Cordon626697a2014-07-10 22:36:37 -070070 private final Set<Call> mCalls = new CopyOnWriteArraySet<Call>();
Santos Cordon681663d2014-01-30 04:32:15 -080071
Sailesh Nepal664837f2014-07-14 16:31:51 -070072 private final ConnectionServiceRepository mConnectionServiceRepository =
73 new ConnectionServiceRepository();
Santos Cordonf3671a62014-05-29 21:51:53 -070074 private final DtmfLocalTonePlayer mDtmfLocalTonePlayer = new DtmfLocalTonePlayer();
75 private final InCallController mInCallController = new InCallController();
76 private final CallAudioManager mCallAudioManager;
77 private final Ringer mRinger;
78 private final Set<CallsManagerListener> mListeners = new HashSet<>();
Santos Cordondeb8c892014-05-30 01:38:03 -070079 private final HeadsetMediaButton mHeadsetMediaButton;
Sailesh Nepalb88795a2014-07-15 14:53:27 -070080 private final WiredHeadsetManager mWiredHeadsetManager;
81 private final TtyManager mTtyManager;
Yorke Leed1346872014-07-28 14:38:45 -070082 private final ProximitySensorManager mProximitySensorManager;
Sailesh Nepal84fa5f82014-04-02 11:01:11 -070083
84 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -070085 * The call the user is currently interacting with. This is the call that should have audio
86 * focus and be visible in the in-call UI.
Santos Cordon4e9fffe2014-03-04 18:13:41 -080087 */
Sailesh Nepal810735e2014-03-18 18:15:46 -070088 private Call mForegroundCall;
Santos Cordon4e9fffe2014-03-04 18:13:41 -080089
Santos Cordon766d04f2014-05-06 10:28:25 -070090 /** Singleton accessor. */
91 static CallsManager getInstance() {
92 return INSTANCE;
93 }
Ben Gilad9f2bed32013-12-12 17:43:26 -080094
Santos Cordon8e8b8d22013-12-19 14:14:05 -080095 /**
Ben Gilad8bdaa462014-02-05 12:53:19 -080096 * Initializes the required Telecomm components.
Santos Cordon8e8b8d22013-12-19 14:14:05 -080097 */
98 private CallsManager() {
Santos Cordona0e5f1a2014-03-31 21:43:00 -070099 TelecommApp app = TelecommApp.getInstance();
Santos Cordona56f2762014-03-24 15:55:53 -0700100
Santos Cordondeb8c892014-05-30 01:38:03 -0700101 StatusBarNotifier statusBarNotifier = new StatusBarNotifier(app, this);
Sailesh Nepalb88795a2014-07-15 14:53:27 -0700102 mWiredHeadsetManager = new WiredHeadsetManager(app);
103 mCallAudioManager = new CallAudioManager(app, statusBarNotifier, mWiredHeadsetManager);
Santos Cordonc7b8eba2014-04-01 15:26:28 -0700104 InCallTonePlayer.Factory playerFactory = new InCallTonePlayer.Factory(mCallAudioManager);
Santos Cordonae193062014-05-21 21:21:49 -0700105 mRinger = new Ringer(mCallAudioManager, this, playerFactory, app);
Santos Cordondeb8c892014-05-30 01:38:03 -0700106 mHeadsetMediaButton = new HeadsetMediaButton(app, this);
Sailesh Nepalb88795a2014-07-15 14:53:27 -0700107 mTtyManager = new TtyManager(app, mWiredHeadsetManager);
Yorke Leed1346872014-07-28 14:38:45 -0700108 mProximitySensorManager = new ProximitySensorManager(app);
Santos Cordonae193062014-05-21 21:21:49 -0700109
Santos Cordondeb8c892014-05-30 01:38:03 -0700110 mListeners.add(statusBarNotifier);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700111 mListeners.add(new CallLogManager(app));
Santos Cordona56f2762014-03-24 15:55:53 -0700112 mListeners.add(new PhoneStateBroadcaster());
Santos Cordonf3671a62014-05-29 21:51:53 -0700113 mListeners.add(mInCallController);
Santos Cordonae193062014-05-21 21:21:49 -0700114 mListeners.add(mRinger);
Santos Cordonc7b8eba2014-04-01 15:26:28 -0700115 mListeners.add(new RingbackPlayer(this, playerFactory));
116 mListeners.add(new InCallToneMonitor(playerFactory, this));
Santos Cordona56f2762014-03-24 15:55:53 -0700117 mListeners.add(mCallAudioManager);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700118 mListeners.add(app.getMissedCallNotifier());
Santos Cordon92a2d812014-04-30 15:19:01 -0700119 mListeners.add(mDtmfLocalTonePlayer);
Santos Cordon81289982014-06-03 16:03:08 -0700120 mListeners.add(mHeadsetMediaButton);
Ihab Awadff7493a2014-06-10 13:47:44 -0700121 mListeners.add(RespondViaSmsManager.getInstance());
Yorke Leed1346872014-07-28 14:38:45 -0700122 mListeners.add(mProximitySensorManager);
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800123 }
124
Santos Cordon766d04f2014-05-06 10:28:25 -0700125 @Override
Tyler Gunncde2e502014-08-12 14:35:58 -0700126 public void onSuccessfulOutgoingCall(Call call, CallState callState) {
Santos Cordon766d04f2014-05-06 10:28:25 -0700127 Log.v(this, "onSuccessfulOutgoingCall, %s", call);
Tyler Gunncde2e502014-08-12 14:35:58 -0700128 setCallState(call, callState);
Santos Cordon766d04f2014-05-06 10:28:25 -0700129 if (mCalls.contains(call)) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700130 // The call's ConnectionService has been updated.
Santos Cordon766d04f2014-05-06 10:28:25 -0700131 for (CallsManagerListener listener : mListeners) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700132 listener.onConnectionServiceChanged(call, null, call.getConnectionService());
Santos Cordon766d04f2014-05-06 10:28:25 -0700133 }
Santos Cordon6cb7ba92014-05-23 14:09:32 -0700134 } else {
135 Log.wtf(this, "unexpected successful call notification: %s", call);
136 return;
Santos Cordon766d04f2014-05-06 10:28:25 -0700137 }
Santos Cordon6cb7ba92014-05-23 14:09:32 -0700138
139 markCallAsDialing(call);
Santos Cordon766d04f2014-05-06 10:28:25 -0700140 }
141
142 @Override
Sailesh Nepal5a73b032014-06-25 15:53:21 -0700143 public void onFailedOutgoingCall(Call call, int errorCode, String errorMsg) {
144 Log.v(this, "onFailedOutgoingCall, call: %s", call);
145 // TODO: Replace disconnect cause with more specific disconnect causes.
146 markCallAsDisconnected(call, errorCode, errorMsg);
147 }
148
149 @Override
150 public void onCancelledOutgoingCall(Call call) {
151 Log.v(this, "onCancelledOutgoingCall, call: %s", call);
152 setCallState(call, CallState.ABORTED);
153 removeCall(call);
Santos Cordon766d04f2014-05-06 10:28:25 -0700154 }
155
156 @Override
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700157 public void onSuccessfulIncomingCall(Call call) {
Santos Cordon766d04f2014-05-06 10:28:25 -0700158 Log.d(this, "onSuccessfulIncomingCall");
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700159 setCallState(call, CallState.RINGING);
Santos Cordon766d04f2014-05-06 10:28:25 -0700160 addCall(call);
161 }
162
163 @Override
164 public void onFailedIncomingCall(Call call) {
Tyler Gunncde2e502014-08-12 14:35:58 -0700165 setCallState(call, CallState.DISCONNECTED);
Santos Cordon766d04f2014-05-06 10:28:25 -0700166 call.removeListener(this);
Ben Gilada0d9f752014-02-26 11:49:03 -0800167 }
168
Ihab Awadcb387ac2014-05-28 16:49:38 -0700169 @Override
170 public void onRequestingRingback(Call call, boolean ringback) {
171 for (CallsManagerListener listener : mListeners) {
172 listener.onRequestingRingback(call, ringback);
173 }
174 }
175
Evan Charlton352105c2014-06-03 14:10:54 -0700176 @Override
177 public void onPostDialWait(Call call, String remaining) {
178 mInCallController.onPostDialWait(call, remaining);
179 }
180
Santos Cordona1610702014-06-04 20:22:56 -0700181 @Override
182 public void onExpiredConferenceCall(Call call) {
183 call.removeListener(this);
184 }
185
186 @Override
187 public void onConfirmedConferenceCall(Call call) {
188 addCall(call);
189 Log.v(this, "confirming Conf call %s", call);
190 for (CallsManagerListener listener : mListeners) {
191 listener.onIsConferencedChanged(call);
192 }
193 }
194
195 @Override
196 public void onParentChanged(Call call) {
197 for (CallsManagerListener listener : mListeners) {
198 listener.onIsConferencedChanged(call);
199 }
200 }
201
202 @Override
203 public void onChildrenChanged(Call call) {
204 for (CallsManagerListener listener : mListeners) {
205 listener.onIsConferencedChanged(call);
206 }
207 }
208
Ihab Awadff7493a2014-06-10 13:47:44 -0700209 @Override
Sailesh Nepal7e669572014-07-08 21:29:12 -0700210 public void onAudioModeIsVoipChanged(Call call) {
211 for (CallsManagerListener listener : mListeners) {
212 listener.onAudioModeIsVoipChanged(call);
213 }
214 }
215
Andrew Lee4a796602014-07-11 17:23:03 -0700216 @Override
217 public void onVideoStateChanged(Call call) {
218 for (CallsManagerListener listener : mListeners) {
219 listener.onVideoStateChanged(call);
220 }
221 }
222
Sailesh Nepal810735e2014-03-18 18:15:46 -0700223 ImmutableCollection<Call> getCalls() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700224 return ImmutableList.copyOf(mCalls);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700225 }
226
227 Call getForegroundCall() {
228 return mForegroundCall;
229 }
230
Santos Cordonae193062014-05-21 21:21:49 -0700231 Ringer getRinger() {
232 return mRinger;
233 }
234
Santos Cordonf3671a62014-05-29 21:51:53 -0700235 InCallController getInCallController() {
236 return mInCallController;
237 }
238
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700239 boolean hasEmergencyCall() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700240 for (Call call : mCalls) {
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700241 if (call.isEmergencyCall()) {
242 return true;
243 }
244 }
245 return false;
246 }
247
248 CallAudioState getAudioState() {
249 return mCallAudioManager.getAudioState();
250 }
251
Sailesh Nepalb88795a2014-07-15 14:53:27 -0700252 boolean isTtySupported() {
253 return mTtyManager.isTtySupported();
254 }
255
256 int getCurrentTtyMode() {
257 return mTtyManager.getCurrentTtyMode();
258 }
259
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800260 /**
Sailesh Nepal664837f2014-07-14 16:31:51 -0700261 * Starts the process to attach the call to a connection service.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800262 *
Evan Charlton89176372014-07-19 18:23:09 -0700263 * @param phoneAccountHandle The phone account which contains the component name of the connection
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700264 * serivce to use for this call.
Evan Charltona05805b2014-03-05 08:21:46 -0800265 * @param extras The optional extras Bundle passed with the intent used for the incoming call.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800266 */
Evan Charlton89176372014-07-19 18:23:09 -0700267 void processIncomingCallIntent(PhoneAccountHandle phoneAccountHandle, Bundle extras) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800268 Log.d(this, "processIncomingCallIntent");
Sailesh Nepal664837f2014-07-14 16:31:51 -0700269 // Create a call with no handle. The handle is eventually set when the call is attached
270 // to a connection service.
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700271 Call call = new Call(
Sailesh Nepal664837f2014-07-14 16:31:51 -0700272 mConnectionServiceRepository,
273 null /* handle */,
274 null /* gatewayInfo */,
Ihab Awadb78b2762014-07-25 15:16:23 -0700275 null /* connectionManagerPhoneAccount */,
Evan Charlton89176372014-07-19 18:23:09 -0700276 phoneAccountHandle,
Sailesh Nepal664837f2014-07-14 16:31:51 -0700277 true /* isIncoming */,
278 false /* isConference */);
279
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700280 call.setExtras(extras);
Santos Cordondf399862014-08-06 04:39:15 -0700281 // TODO: Move this to be a part of addCall()
Santos Cordon766d04f2014-05-06 10:28:25 -0700282 call.addListener(this);
Sailesh Nepal664837f2014-07-14 16:31:51 -0700283 call.startCreateConnection();
Ben Gilada0d9f752014-02-26 11:49:03 -0800284 }
285
286 /**
Yorke Lee33501632014-03-17 19:24:12 -0700287 * Attempts to issue/connect the specified call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800288 *
Yorke Lee33501632014-03-17 19:24:12 -0700289 * @param handle Handle to connect the call with.
Yorke Lee33501632014-03-17 19:24:12 -0700290 * @param gatewayInfo Optional gateway information that can be used to route the call to the
Nancy Chen53ceedc2014-07-08 18:56:51 -0700291 * actual dialed handle via a gateway provider. May be null.
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700292 * @param speakerphoneOn Whether or not to turn the speakerphone on once the call connects.
Tyler Gunnc4abd912014-07-08 14:22:10 -0700293 * @param videoState The desired video state for the outgoing call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800294 */
Evan Charlton89176372014-07-19 18:23:09 -0700295 void placeOutgoingCall(Uri handle, GatewayInfo gatewayInfo, PhoneAccountHandle accountHandle,
Yorke Lee6f3f7af2014-07-11 10:59:46 -0700296 boolean speakerphoneOn, int videoState) {
Tyler Gunnc4abd912014-07-08 14:22:10 -0700297
Santos Cordonb7af09e2014-08-06 04:30:01 -0700298 // We only allow a single outgoing call at any given time. Before placing a call, make sure
299 // there doesn't already exist another outgoing call.
300 Call currentOutgoing = getFirstCallWithState(CallState.NEW, CallState.DIALING);
301 if (currentOutgoing != null) {
302 Log.i(this, "Canceling simultaneous outgoing call.");
303 return;
304 }
305
Santos Cordon7cdb9092014-07-24 21:33:33 -0700306 TelecommApp app = TelecommApp.getInstance();
Yorke Lee33501632014-03-17 19:24:12 -0700307 final Uri uriHandle = (gatewayInfo == null) ? handle : gatewayInfo.getGatewayHandle();
308
309 if (gatewayInfo == null) {
Santos Cordonb58f4532014-05-29 11:59:06 -0700310 Log.i(this, "Creating a new outgoing call with handle: %s", Log.piiHandle(uriHandle));
Yorke Lee33501632014-03-17 19:24:12 -0700311 } else {
312 Log.i(this, "Creating a new outgoing call with gateway handle: %s, original handle: %s",
313 Log.pii(uriHandle), Log.pii(handle));
314 }
Santos Cordon766d04f2014-05-06 10:28:25 -0700315
Santos Cordon7cdb9092014-07-24 21:33:33 -0700316 // Only dial with the requested phoneAccount if it is still valid. Otherwise treat this call
317 // as if a phoneAccount was not specified (does the default behavior instead).
318 if (accountHandle != null) {
319 List<PhoneAccountHandle> enabledAccounts =
320 app.getPhoneAccountRegistrar().getEnabledPhoneAccounts();
321 if (!enabledAccounts.contains(accountHandle)) {
322 accountHandle = null;
323 }
324 }
325
Santos Cordona1610702014-06-04 20:22:56 -0700326 Call call = new Call(
Sailesh Nepal664837f2014-07-14 16:31:51 -0700327 mConnectionServiceRepository,
328 uriHandle,
329 gatewayInfo,
Ihab Awadb78b2762014-07-25 15:16:23 -0700330 null /* connectionManagerPhoneAccount */,
Evan Charlton89176372014-07-19 18:23:09 -0700331 accountHandle,
Sailesh Nepal664837f2014-07-14 16:31:51 -0700332 false /* isIncoming */,
333 false /* isConference */);
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700334 call.setStartWithSpeakerphoneOn(speakerphoneOn);
Tyler Gunnc4abd912014-07-08 14:22:10 -0700335 call.setVideoState(videoState);
Santos Cordon766d04f2014-05-06 10:28:25 -0700336
Santos Cordondf399862014-08-06 04:39:15 -0700337 // TODO: Move this to be a part of addCall()
Santos Cordon766d04f2014-05-06 10:28:25 -0700338 call.addListener(this);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700339 addCall(call);
Nancy Chen53ceedc2014-07-08 18:56:51 -0700340
Nancy Chend9de92c2014-07-21 16:09:13 -0700341 // This block of code will attempt to pre-determine a phone account
Santos Cordon7cdb9092014-07-24 21:33:33 -0700342 final boolean emergencyCall = TelephonyUtil.shouldProcessAsEmergency(app, call.getHandle());
Nancy Chend9de92c2014-07-21 16:09:13 -0700343 if (emergencyCall) {
Ihab Awad69eb0f52014-07-18 11:20:37 -0700344 // Emergency -- CreateConnectionProcessor will choose accounts automatically
Ihab Awadb78b2762014-07-25 15:16:23 -0700345 call.setTargetPhoneAccount(null);
Nancy Chend9de92c2014-07-21 16:09:13 -0700346 } else if (accountHandle != null) {
Santos Cordon7cdb9092014-07-24 21:33:33 -0700347 Log.d(this, "CALL with phone account: " + accountHandle);
Ihab Awadb78b2762014-07-25 15:16:23 -0700348 call.setTargetPhoneAccount(accountHandle);
Nancy Chend9de92c2014-07-21 16:09:13 -0700349 } else {
350 // No preset account, check if default exists
Santos Cordon7cdb9092014-07-24 21:33:33 -0700351 PhoneAccountHandle defaultAccountHandle =
352 app.getPhoneAccountRegistrar().getDefaultOutgoingPhoneAccount();
Evan Charlton89176372014-07-19 18:23:09 -0700353 if (defaultAccountHandle != null) {
Ihab Awadb78b2762014-07-25 15:16:23 -0700354 call.setTargetPhoneAccount(defaultAccountHandle);
Ihab Awad104f8062014-07-17 11:29:35 -0700355 }
Nancy Chen53ceedc2014-07-08 18:56:51 -0700356 }
Nancy Chend9de92c2014-07-21 16:09:13 -0700357
Ihab Awadb78b2762014-07-25 15:16:23 -0700358 if (call.getTargetPhoneAccount() != null || emergencyCall) {
Nancy Chend9de92c2014-07-21 16:09:13 -0700359 // If the account is selected, proceed to place the outgoing call
360 call.startCreateConnection();
361 } else {
362 // This is the state where the user is expected to select an account
363 call.setState(CallState.PRE_DIAL_WAIT);
364 }
Yorke Leef98fb572014-03-05 10:56:55 -0800365 }
366
367 /**
Santos Cordona1610702014-06-04 20:22:56 -0700368 * Attempts to start a conference call for the specified call.
369 *
Santos Cordon12d61822014-07-29 16:02:20 -0700370 * @param call The call to conference.
371 * @param otherCall The other call to conference with.
Santos Cordona1610702014-06-04 20:22:56 -0700372 */
Santos Cordon12d61822014-07-29 16:02:20 -0700373 void conference(Call call, Call otherCall) {
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700374 Call conferenceCall = new Call(
Sailesh Nepal664837f2014-07-14 16:31:51 -0700375 mConnectionServiceRepository,
376 null /* handle */,
377 null /* gatewayInfo */,
Ihab Awadb78b2762014-07-25 15:16:23 -0700378 null /* connectionManagerPhoneAccount */,
379 null /* targetPhoneAccount */,
Sailesh Nepal664837f2014-07-14 16:31:51 -0700380 false /* isIncoming */,
381 true /* isConference */);
Santos Cordona1610702014-06-04 20:22:56 -0700382 conferenceCall.addListener(this);
383 call.conferenceInto(conferenceCall);
384 }
385
386 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800387 * Instructs Telecomm to answer the specified call. Intended to be invoked by the in-call
388 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
389 * the user opting to answer said call.
Andrew Lee38931d02014-07-16 10:17:36 -0700390 *
391 * @param call The call to answer.
392 * @param videoState The video state in which to answer the call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800393 */
Andrew Lee38931d02014-07-16 10:17:36 -0700394 void answerCall(Call call, int videoState) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700395 if (!mCalls.contains(call)) {
396 Log.i(this, "Request to answer a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800397 } else {
Santos Cordon40f78c22014-04-07 02:11:42 -0700398 // If the foreground call is not the ringing call and it is currently isActive() or
399 // DIALING, put it on hold before answering the call.
400 if (mForegroundCall != null && mForegroundCall != call &&
401 (mForegroundCall.isActive() ||
402 mForegroundCall.getState() == CallState.DIALING)) {
403 Log.v(this, "Holding active/dialing call %s before answering incoming call %s.",
404 mForegroundCall, call);
405 mForegroundCall.hold();
Santos Cordondf399862014-08-06 04:39:15 -0700406 // TODO: Wait until we get confirmation of the active call being
Santos Cordon40f78c22014-04-07 02:11:42 -0700407 // on-hold before answering the new call.
Santos Cordondf399862014-08-06 04:39:15 -0700408 // TODO: Import logic from CallManager.acceptCall()
Santos Cordon40f78c22014-04-07 02:11:42 -0700409 }
410
Santos Cordona56f2762014-03-24 15:55:53 -0700411 for (CallsManagerListener listener : mListeners) {
412 listener.onIncomingCallAnswered(call);
413 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800414
Santos Cordon61d0f702014-02-19 02:52:23 -0800415 // We do not update the UI until we get confirmation of the answer() through
Sailesh Nepale59bb192014-04-01 18:33:59 -0700416 // {@link #markCallAsActive}.
Andrew Lee38931d02014-07-16 10:17:36 -0700417 call.answer(videoState);
Santos Cordon61d0f702014-02-19 02:52:23 -0800418 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800419 }
420
421 /**
422 * Instructs Telecomm to reject the specified call. Intended to be invoked by the in-call
423 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
424 * the user opting to reject said call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800425 */
Ihab Awadff7493a2014-06-10 13:47:44 -0700426 void rejectCall(Call call, boolean rejectWithMessage, String textMessage) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700427 if (!mCalls.contains(call)) {
428 Log.i(this, "Request to reject a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800429 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700430 for (CallsManagerListener listener : mListeners) {
Ihab Awadff7493a2014-06-10 13:47:44 -0700431 listener.onIncomingCallRejected(call, rejectWithMessage, textMessage);
Santos Cordona56f2762014-03-24 15:55:53 -0700432 }
Ihab Awadff7493a2014-06-10 13:47:44 -0700433 call.reject(rejectWithMessage, textMessage);
Santos Cordon61d0f702014-02-19 02:52:23 -0800434 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800435 }
436
437 /**
Ihab Awad74549ec2014-03-10 15:33:25 -0700438 * Instructs Telecomm to play the specified DTMF tone within the specified call.
439 *
Ihab Awad74549ec2014-03-10 15:33:25 -0700440 * @param digit The DTMF digit to play.
441 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700442 void playDtmfTone(Call call, char digit) {
443 if (!mCalls.contains(call)) {
444 Log.i(this, "Request to play DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700445 } else {
446 call.playDtmfTone(digit);
Santos Cordon92a2d812014-04-30 15:19:01 -0700447 mDtmfLocalTonePlayer.playTone(call, digit);
Ihab Awad74549ec2014-03-10 15:33:25 -0700448 }
449 }
450
451 /**
452 * Instructs Telecomm to stop the currently playing DTMF tone, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700453 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700454 void stopDtmfTone(Call call) {
455 if (!mCalls.contains(call)) {
456 Log.i(this, "Request to stop DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700457 } else {
458 call.stopDtmfTone();
Santos Cordon92a2d812014-04-30 15:19:01 -0700459 mDtmfLocalTonePlayer.stopTone(call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700460 }
461 }
462
463 /**
Evan Charlton352105c2014-06-03 14:10:54 -0700464 * Instructs Telecomm to continue (or not) the current post-dial DTMF string, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700465 */
Evan Charlton352105c2014-06-03 14:10:54 -0700466 void postDialContinue(Call call, boolean proceed) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700467 if (!mCalls.contains(call)) {
468 Log.i(this, "Request to continue post-dial string in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700469 } else {
Evan Charlton352105c2014-06-03 14:10:54 -0700470 call.postDialContinue(proceed);
Ihab Awad74549ec2014-03-10 15:33:25 -0700471 }
472 }
473
474 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800475 * Instructs Telecomm to disconnect the specified call. Intended to be invoked by the
476 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
477 * the user hitting the end-call button.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800478 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700479 void disconnectCall(Call call) {
Santos Cordon682fe6b2014-05-20 08:56:39 -0700480 Log.v(this, "disconnectCall %s", call);
481
Sailesh Nepale59bb192014-04-01 18:33:59 -0700482 if (!mCalls.contains(call)) {
483 Log.w(this, "Unknown call (%s) asked to disconnect", call);
Santos Cordon049b7b62014-01-30 05:34:26 -0800484 } else {
485 call.disconnect();
486 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800487 }
Santos Cordon681663d2014-01-30 04:32:15 -0800488
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700489 /**
490 * Instructs Telecomm to put the specified call on hold. Intended to be invoked by the
491 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
492 * the user hitting the hold button during an active call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700493 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700494 void holdCall(Call call) {
495 if (!mCalls.contains(call)) {
496 Log.w(this, "Unknown call (%s) asked to be put on hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700497 } else {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700498 Log.d(this, "Putting call on hold: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700499 call.hold();
500 }
501 }
502
503 /**
504 * Instructs Telecomm to release the specified call from hold. Intended to be invoked by
505 * the in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered
506 * by the user hitting the hold button during a held call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700507 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700508 void unholdCall(Call call) {
509 if (!mCalls.contains(call)) {
510 Log.w(this, "Unknown call (%s) asked to be removed from hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700511 } else {
Santos Cordonc7e85d42014-05-22 02:51:48 -0700512 Log.d(this, "unholding call: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700513 call.unhold();
514 }
515 }
516
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700517 /** Called by the in-call UI to change the mute state. */
518 void mute(boolean shouldMute) {
519 mCallAudioManager.mute(shouldMute);
520 }
521
522 /**
523 * Called by the in-call UI to change the audio route, for example to change from earpiece to
524 * speaker phone.
525 */
526 void setAudioRoute(int route) {
527 mCallAudioManager.setAudioRoute(route);
528 }
529
Yorke Leed1346872014-07-28 14:38:45 -0700530 /** Called by the in-call UI to turn the proximity sensor on. */
531 void turnOnProximitySensor() {
532 mProximitySensorManager.turnOn();
533 }
534
535 /**
536 * Called by the in-call UI to turn the proximity sensor off.
537 * @param screenOnImmediately If true, the screen will be turned on immediately. Otherwise,
538 * the screen will be kept off until the proximity sensor goes negative.
539 */
540 void turnOffProximitySensor(boolean screenOnImmediately) {
541 mProximitySensorManager.turnOff(screenOnImmediately);
542 }
543
Sailesh Nepal77da19e2014-07-02 21:31:16 -0700544 void phoneAccountClicked(Call call) {
545 if (!mCalls.contains(call)) {
546 Log.i(this, "phoneAccountClicked in a non-existent call %s", call);
547 } else {
548 call.phoneAccountClicked();
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700549 }
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700550 }
551
Evan Charlton89176372014-07-19 18:23:09 -0700552 void phoneAccountSelected(Call call, PhoneAccountHandle account) {
Nancy Chen53ceedc2014-07-08 18:56:51 -0700553 if (!mCalls.contains(call)) {
554 Log.i(this, "Attemped to add account to unknown call %s", call);
555 } else {
Ihab Awadb78b2762014-07-25 15:16:23 -0700556 call.setTargetPhoneAccount(account);
Nancy Chen53ceedc2014-07-08 18:56:51 -0700557 call.startCreateConnection();
558 }
559 }
560
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700561 /** Called when the audio state changes. */
562 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState) {
563 Log.v(this, "onAudioStateChanged, audioState: %s -> %s", oldAudioState, newAudioState);
Santos Cordona56f2762014-03-24 15:55:53 -0700564 for (CallsManagerListener listener : mListeners) {
565 listener.onAudioStateChanged(oldAudioState, newAudioState);
566 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700567 }
568
Sailesh Nepale59bb192014-04-01 18:33:59 -0700569 void markCallAsRinging(Call call) {
570 setCallState(call, CallState.RINGING);
Santos Cordon681663d2014-01-30 04:32:15 -0800571 }
572
Sailesh Nepale59bb192014-04-01 18:33:59 -0700573 void markCallAsDialing(Call call) {
574 setCallState(call, CallState.DIALING);
Santos Cordon681663d2014-01-30 04:32:15 -0800575 }
576
Sailesh Nepale59bb192014-04-01 18:33:59 -0700577 void markCallAsActive(Call call) {
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700578 if (call.getConnectTimeMillis() == 0) {
579 call.setConnectTimeMillis(System.currentTimeMillis());
580 }
Sailesh Nepale59bb192014-04-01 18:33:59 -0700581 setCallState(call, CallState.ACTIVE);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700582
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700583 if (call.getStartWithSpeakerphoneOn()) {
584 setAudioRoute(CallAudioState.ROUTE_SPEAKER);
585 }
Santos Cordon681663d2014-01-30 04:32:15 -0800586 }
587
Sailesh Nepale59bb192014-04-01 18:33:59 -0700588 void markCallAsOnHold(Call call) {
589 setCallState(call, CallState.ON_HOLD);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700590 }
591
Santos Cordon049b7b62014-01-30 05:34:26 -0800592 /**
593 * Marks the specified call as DISCONNECTED and notifies the in-call app. If this was the last
594 * live call, then also disconnect from the in-call controller.
595 *
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700596 * @param disconnectCause The disconnect reason, see {@link android.telephony.DisconnectCause}.
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700597 * @param disconnectMessage Optional message about the disconnect.
Santos Cordon049b7b62014-01-30 05:34:26 -0800598 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700599 void markCallAsDisconnected(Call call, int disconnectCause, String disconnectMessage) {
600 call.setDisconnectCause(disconnectCause, disconnectMessage);
601 setCallState(call, CallState.DISCONNECTED);
Sailesh Nepal77da19e2014-07-02 21:31:16 -0700602 removeCall(call);
Sailesh Nepal6ab6fb72014-04-01 20:03:19 -0700603 }
604
Ben Gilada0d9f752014-02-26 11:49:03 -0800605 /**
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700606 * Cleans up any calls currently associated with the specified connection service when the
Sailesh Nepal905dfba2014-07-14 08:20:41 -0700607 * service binder disconnects unexpectedly.
Santos Cordon4b2c1192014-03-19 18:15:38 -0700608 *
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700609 * @param service The connection service that disconnected.
Santos Cordon4b2c1192014-03-19 18:15:38 -0700610 */
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700611 void handleConnectionServiceDeath(ConnectionServiceWrapper service) {
612 Preconditions.checkNotNull(service);
Sailesh Nepale59bb192014-04-01 18:33:59 -0700613 for (Call call : ImmutableList.copyOf(mCalls)) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700614 if (call.getConnectionService() == service) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700615 markCallAsDisconnected(call, DisconnectCause.ERROR_UNSPECIFIED, null);
Santos Cordon4b2c1192014-03-19 18:15:38 -0700616 }
617 }
618 }
619
Santos Cordondeb8c892014-05-30 01:38:03 -0700620 boolean hasAnyCalls() {
621 return !mCalls.isEmpty();
622 }
623
Santos Cordonc7e85d42014-05-22 02:51:48 -0700624 boolean hasActiveOrHoldingCall() {
Santos Cordon23baed32014-06-27 14:45:39 -0700625 return getFirstCallWithState(CallState.ACTIVE, CallState.ON_HOLD) != null;
Santos Cordonc7e85d42014-05-22 02:51:48 -0700626 }
627
628 boolean hasRingingCall() {
Santos Cordon23baed32014-06-27 14:45:39 -0700629 return getFirstCallWithState(CallState.RINGING) != null;
Santos Cordonc7e85d42014-05-22 02:51:48 -0700630 }
631
Santos Cordondeb8c892014-05-30 01:38:03 -0700632 boolean onMediaButton(int type) {
633 if (hasAnyCalls()) {
634 if (HeadsetMediaButton.SHORT_PRESS == type) {
635 Call ringingCall = getFirstCallWithState(CallState.RINGING);
636 if (ringingCall == null) {
637 mCallAudioManager.toggleMute();
638 return true;
639 } else {
Andrew Lee38931d02014-07-16 10:17:36 -0700640 ringingCall.answer(ringingCall.getVideoState());
Santos Cordondeb8c892014-05-30 01:38:03 -0700641 return true;
642 }
643 } else if (HeadsetMediaButton.LONG_PRESS == type) {
644 Log.d(this, "handleHeadsetHook: longpress -> hangup");
645 Call callToHangup = getFirstCallWithState(
646 CallState.RINGING, CallState.DIALING, CallState.ACTIVE, CallState.ON_HOLD);
647 if (callToHangup != null) {
648 callToHangup.disconnect();
649 return true;
650 }
651 }
652 }
653 return false;
654 }
655
656 /**
Santos Cordon10838c22014-06-11 17:36:04 -0700657 * Checks to see if the specified call is the only high-level call and if so, enable the
658 * "Add-call" button. We allow you to add a second call but not a third or beyond.
659 *
660 * @param call The call to test for add-call.
661 * @return Whether the add-call feature should be enabled for the call.
662 */
663 protected boolean isAddCallCapable(Call call) {
664 if (call.getParentCall() != null) {
665 // Never true for child calls.
666 return false;
667 }
668
669 // Loop through all the other calls and there exists a top level (has no parent) call
670 // that is not the specified call, return false.
671 for (Call otherCall : mCalls) {
672 if (call != otherCall && otherCall.getParentCall() == null) {
673 return false;
674 }
675 }
676 return true;
677 }
678
679 /**
Santos Cordondeb8c892014-05-30 01:38:03 -0700680 * Returns the first call that it finds with the given states. The states are treated as having
681 * priority order so that any call with the first state will be returned before any call with
682 * states listed later in the parameter list.
683 */
Santos Cordon23baed32014-06-27 14:45:39 -0700684 Call getFirstCallWithState(CallState... states) {
Santos Cordondeb8c892014-05-30 01:38:03 -0700685 for (CallState currentState : states) {
Santos Cordon23baed32014-06-27 14:45:39 -0700686 // check the foreground first
687 if (mForegroundCall != null && mForegroundCall.getState() == currentState) {
688 return mForegroundCall;
689 }
690
Santos Cordondeb8c892014-05-30 01:38:03 -0700691 for (Call call : mCalls) {
692 if (currentState == call.getState()) {
693 return call;
694 }
695 }
696 }
697 return null;
698 }
699
Santos Cordon4b2c1192014-03-19 18:15:38 -0700700 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800701 * Adds the specified call to the main list of live calls.
702 *
703 * @param call The call to add.
704 */
705 private void addCall(Call call) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700706 mCalls.add(call);
Santos Cordon40f78c22014-04-07 02:11:42 -0700707
Santos Cordondf399862014-08-06 04:39:15 -0700708 // TODO: Update mForegroundCall prior to invoking
Santos Cordon40f78c22014-04-07 02:11:42 -0700709 // onCallAdded for calls which immediately take the foreground (like the first call).
Santos Cordona56f2762014-03-24 15:55:53 -0700710 for (CallsManagerListener listener : mListeners) {
711 listener.onCallAdded(call);
712 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700713 updateForegroundCall();
Ben Gilada0d9f752014-02-26 11:49:03 -0800714 }
715
Sailesh Nepal810735e2014-03-18 18:15:46 -0700716 private void removeCall(Call call) {
Santos Cordonc499c1c2014-04-14 17:13:14 -0700717 Log.v(this, "removeCall(%s)", call);
Sailesh Nepal4857f472014-04-07 22:26:27 -0700718
Santos Cordon766d04f2014-05-06 10:28:25 -0700719 call.removeListener(this);
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700720 call.clearConnectionService();
Sailesh Nepale59bb192014-04-01 18:33:59 -0700721
722 boolean shouldNotify = false;
723 if (mCalls.contains(call)) {
724 mCalls.remove(call);
725 shouldNotify = true;
Santos Cordona56f2762014-03-24 15:55:53 -0700726 }
Ben Gilada0d9f752014-02-26 11:49:03 -0800727
Sailesh Nepale59bb192014-04-01 18:33:59 -0700728 // Only broadcast changes for calls that are being tracked.
729 if (shouldNotify) {
730 for (CallsManagerListener listener : mListeners) {
731 listener.onCallRemoved(call);
732 }
733 updateForegroundCall();
Sailesh Nepal810735e2014-03-18 18:15:46 -0700734 }
735 }
Evan Charlton5c670a92014-03-06 14:58:20 -0800736
Sailesh Nepal810735e2014-03-18 18:15:46 -0700737 /**
Santos Cordon1ae2b852014-03-19 03:03:10 -0700738 * Sets the specified state on the specified call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700739 *
740 * @param call The call.
741 * @param newState The new state of the call.
742 */
743 private void setCallState(Call call, CallState newState) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700744 Preconditions.checkNotNull(newState);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700745 CallState oldState = call.getState();
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700746 Log.i(this, "setCallState %s -> %s, call: %s", oldState, newState, call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700747 if (newState != oldState) {
748 // Unfortunately, in the telephony world the radio is king. So if the call notifies
749 // us that the call is in a particular state, we allow it even if it doesn't make
750 // sense (e.g., ACTIVE -> RINGING).
Santos Cordondf399862014-08-06 04:39:15 -0700751 // TODO: Consider putting a stop to the above and turning CallState
Sailesh Nepal810735e2014-03-18 18:15:46 -0700752 // into a well-defined state machine.
Santos Cordondf399862014-08-06 04:39:15 -0700753 // TODO: Define expected state transitions here, and log when an
Sailesh Nepal810735e2014-03-18 18:15:46 -0700754 // unexpected transition occurs.
755 call.setState(newState);
756
757 // Only broadcast state change for calls that are being tracked.
Sailesh Nepale59bb192014-04-01 18:33:59 -0700758 if (mCalls.contains(call)) {
Santos Cordona56f2762014-03-24 15:55:53 -0700759 for (CallsManagerListener listener : mListeners) {
760 listener.onCallStateChanged(call, oldState, newState);
761 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700762 updateForegroundCall();
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800763 }
764 }
765 }
766
767 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700768 * Checks which call should be visible to the user and have audio focus.
Evan Charlton5c670a92014-03-06 14:58:20 -0800769 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700770 private void updateForegroundCall() {
771 Call newForegroundCall = null;
Sailesh Nepale59bb192014-04-01 18:33:59 -0700772 for (Call call : mCalls) {
Santos Cordondf399862014-08-06 04:39:15 -0700773 // TODO: Foreground-ness needs to be explicitly set. No call, regardless
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700774 // of its state will be foreground by default and instead the connection service should
775 // be notified when its calls enter and exit foreground state. Foreground will mean that
Santos Cordon40f78c22014-04-07 02:11:42 -0700776 // the call should play audio and listen to microphone if it wants.
777
778 // Active calls have priority.
779 if (call.isActive()) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700780 newForegroundCall = call;
Evan Charlton5c670a92014-03-06 14:58:20 -0800781 break;
Sailesh Nepal810735e2014-03-18 18:15:46 -0700782 }
Santos Cordon40f78c22014-04-07 02:11:42 -0700783
784 if (call.isAlive() || call.getState() == CallState.RINGING) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700785 newForegroundCall = call;
Santos Cordon40f78c22014-04-07 02:11:42 -0700786 // Don't break in case there's an active call that has priority.
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800787 }
788 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800789
Sailesh Nepal810735e2014-03-18 18:15:46 -0700790 if (newForegroundCall != mForegroundCall) {
Santos Cordon40f78c22014-04-07 02:11:42 -0700791 Log.v(this, "Updating foreground call, %s -> %s.", mForegroundCall, newForegroundCall);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700792 Call oldForegroundCall = mForegroundCall;
793 mForegroundCall = newForegroundCall;
794
Santos Cordona56f2762014-03-24 15:55:53 -0700795 for (CallsManagerListener listener : mListeners) {
796 listener.onForegroundCallChanged(oldForegroundCall, mForegroundCall);
797 }
Santos Cordon681663d2014-01-30 04:32:15 -0800798 }
799 }
Ben Gilad9f2bed32013-12-12 17:43:26 -0800800}