blob: e7a8c70eba1308e4202305663469e15e5ed7cbc6 [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;
Ben Giladc5b22692014-02-18 20:03:22 -080022import android.telecomm.CallServiceDescriptor;
Santos Cordon681663d2014-01-30 04:32:15 -080023import android.telecomm.CallState;
Yorke Lee33501632014-03-17 19:24:12 -070024import android.telecomm.GatewayInfo;
Ihab Awad98a55602014-06-30 21:27:28 -070025import android.telecomm.PhoneAccount;
Santos Cordon79ff2bc2014-03-27 15:31:27 -070026import android.telephony.DisconnectCause;
Santos Cordon8e8b8d22013-12-19 14:14:05 -080027
Santos Cordon681663d2014-01-30 04:32:15 -080028import com.google.common.base.Preconditions;
Sailesh Nepal810735e2014-03-18 18:15:46 -070029import com.google.common.collect.ImmutableCollection;
30import com.google.common.collect.ImmutableList;
Ben Gilad9f2bed32013-12-12 17:43:26 -080031
Santos Cordonf3671a62014-05-29 21:51:53 -070032import java.util.HashSet;
33import java.util.LinkedHashSet;
Santos Cordona56f2762014-03-24 15:55:53 -070034import java.util.Set;
Santos Cordon626697a2014-07-10 22:36:37 -070035import java.util.concurrent.CopyOnWriteArraySet;
Ben Gilad9f2bed32013-12-12 17:43:26 -080036
Ben Giladdd8c6082013-12-30 14:44:08 -080037/**
38 * Singleton.
39 *
40 * NOTE(gilad): by design most APIs are package private, use the relevant adapter/s to allow
41 * access from other packages specifically refraining from passing the CallsManager instance
42 * beyond the com.android.telecomm package boundary.
43 */
Santos Cordon64c7e962014-07-02 15:15:27 -070044public final class CallsManager extends Call.ListenerBase {
Ben Gilada0d9f752014-02-26 11:49:03 -080045
Santos Cordon74d420b2014-05-07 14:38:47 -070046 // TODO(santoscordon): Consider renaming this CallsManagerPlugin.
Sailesh Nepal810735e2014-03-18 18:15:46 -070047 interface CallsManagerListener {
48 void onCallAdded(Call call);
49 void onCallRemoved(Call call);
50 void onCallStateChanged(Call call, CallState oldState, CallState newState);
Sailesh Nepalc92c4362014-07-04 18:33:21 -070051 void onConnectionServiceChanged(
Sailesh Nepal8c85dee2014-04-07 22:21:40 -070052 Call call,
Sailesh Nepalc92c4362014-07-04 18:33:21 -070053 ConnectionServiceWrapper oldService,
54 ConnectionServiceWrapper newService);
Sailesh Nepal810735e2014-03-18 18:15:46 -070055 void onIncomingCallAnswered(Call call);
Ihab Awadff7493a2014-06-10 13:47:44 -070056 void onIncomingCallRejected(Call call, boolean rejectWithMessage, String textMessage);
Sailesh Nepal810735e2014-03-18 18:15:46 -070057 void onForegroundCallChanged(Call oldForegroundCall, Call newForegroundCall);
Sailesh Nepal6aca10a2014-03-24 16:11:02 -070058 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState);
Ihab Awadcb387ac2014-05-28 16:49:38 -070059 void onRequestingRingback(Call call, boolean ringback);
Santos Cordona1610702014-06-04 20:22:56 -070060 void onIsConferencedChanged(Call call);
Sailesh Nepal7e669572014-07-08 21:29:12 -070061 void onAudioModeIsVoipChanged(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
Santos Cordonf3671a62014-05-29 21:51:53 -070072 private final DtmfLocalTonePlayer mDtmfLocalTonePlayer = new DtmfLocalTonePlayer();
73 private final InCallController mInCallController = new InCallController();
74 private final CallAudioManager mCallAudioManager;
75 private final Ringer mRinger;
76 private final Set<CallsManagerListener> mListeners = new HashSet<>();
Santos Cordondeb8c892014-05-30 01:38:03 -070077 private final HeadsetMediaButton mHeadsetMediaButton;
Sailesh Nepal84fa5f82014-04-02 11:01:11 -070078
79 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -070080 * The call the user is currently interacting with. This is the call that should have audio
81 * focus and be visible in the in-call UI.
Santos Cordon4e9fffe2014-03-04 18:13:41 -080082 */
Sailesh Nepal810735e2014-03-18 18:15:46 -070083 private Call mForegroundCall;
Santos Cordon4e9fffe2014-03-04 18:13:41 -080084
Santos Cordon766d04f2014-05-06 10:28:25 -070085 /** Singleton accessor. */
86 static CallsManager getInstance() {
87 return INSTANCE;
88 }
Ben Gilad9f2bed32013-12-12 17:43:26 -080089
Santos Cordon8e8b8d22013-12-19 14:14:05 -080090 /**
Ben Gilad8bdaa462014-02-05 12:53:19 -080091 * Initializes the required Telecomm components.
Santos Cordon8e8b8d22013-12-19 14:14:05 -080092 */
93 private CallsManager() {
Santos Cordona0e5f1a2014-03-31 21:43:00 -070094 TelecommApp app = TelecommApp.getInstance();
Santos Cordona56f2762014-03-24 15:55:53 -070095
Santos Cordondeb8c892014-05-30 01:38:03 -070096 StatusBarNotifier statusBarNotifier = new StatusBarNotifier(app, this);
97 mCallAudioManager = new CallAudioManager(app, statusBarNotifier);
Santos Cordonc7b8eba2014-04-01 15:26:28 -070098 InCallTonePlayer.Factory playerFactory = new InCallTonePlayer.Factory(mCallAudioManager);
Santos Cordonae193062014-05-21 21:21:49 -070099 mRinger = new Ringer(mCallAudioManager, this, playerFactory, app);
Santos Cordondeb8c892014-05-30 01:38:03 -0700100 mHeadsetMediaButton = new HeadsetMediaButton(app, this);
Santos Cordonae193062014-05-21 21:21:49 -0700101
Santos Cordondeb8c892014-05-30 01:38:03 -0700102 mListeners.add(statusBarNotifier);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700103 mListeners.add(new CallLogManager(app));
Santos Cordona56f2762014-03-24 15:55:53 -0700104 mListeners.add(new PhoneStateBroadcaster());
Santos Cordonf3671a62014-05-29 21:51:53 -0700105 mListeners.add(mInCallController);
Santos Cordonae193062014-05-21 21:21:49 -0700106 mListeners.add(mRinger);
Santos Cordonc7b8eba2014-04-01 15:26:28 -0700107 mListeners.add(new RingbackPlayer(this, playerFactory));
108 mListeners.add(new InCallToneMonitor(playerFactory, this));
Santos Cordona56f2762014-03-24 15:55:53 -0700109 mListeners.add(mCallAudioManager);
Santos Cordona0e5f1a2014-03-31 21:43:00 -0700110 mListeners.add(app.getMissedCallNotifier());
Santos Cordon92a2d812014-04-30 15:19:01 -0700111 mListeners.add(mDtmfLocalTonePlayer);
Santos Cordon81289982014-06-03 16:03:08 -0700112 mListeners.add(mHeadsetMediaButton);
Ihab Awadff7493a2014-06-10 13:47:44 -0700113 mListeners.add(RespondViaSmsManager.getInstance());
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800114 }
115
Santos Cordon766d04f2014-05-06 10:28:25 -0700116 @Override
117 public void onSuccessfulOutgoingCall(Call call) {
118 Log.v(this, "onSuccessfulOutgoingCall, %s", call);
119 if (mCalls.contains(call)) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700120 // The call's ConnectionService has been updated.
Santos Cordon766d04f2014-05-06 10:28:25 -0700121 for (CallsManagerListener listener : mListeners) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700122 listener.onConnectionServiceChanged(call, null, call.getConnectionService());
Santos Cordon766d04f2014-05-06 10:28:25 -0700123 }
Santos Cordon6cb7ba92014-05-23 14:09:32 -0700124 } else {
125 Log.wtf(this, "unexpected successful call notification: %s", call);
126 return;
Santos Cordon766d04f2014-05-06 10:28:25 -0700127 }
Santos Cordon6cb7ba92014-05-23 14:09:32 -0700128
129 markCallAsDialing(call);
Santos Cordon766d04f2014-05-06 10:28:25 -0700130 }
131
132 @Override
Sailesh Nepal5a73b032014-06-25 15:53:21 -0700133 public void onFailedOutgoingCall(Call call, int errorCode, String errorMsg) {
134 Log.v(this, "onFailedOutgoingCall, call: %s", call);
135 // TODO: Replace disconnect cause with more specific disconnect causes.
136 markCallAsDisconnected(call, errorCode, errorMsg);
137 }
138
139 @Override
140 public void onCancelledOutgoingCall(Call call) {
141 Log.v(this, "onCancelledOutgoingCall, call: %s", call);
142 setCallState(call, CallState.ABORTED);
143 removeCall(call);
Santos Cordon766d04f2014-05-06 10:28:25 -0700144 }
145
146 @Override
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700147 public void onSuccessfulIncomingCall(Call call) {
Santos Cordon766d04f2014-05-06 10:28:25 -0700148 Log.d(this, "onSuccessfulIncomingCall");
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700149 setCallState(call, CallState.RINGING);
Santos Cordon766d04f2014-05-06 10:28:25 -0700150 addCall(call);
151 }
152
153 @Override
154 public void onFailedIncomingCall(Call call) {
155 call.removeListener(this);
Ben Gilada0d9f752014-02-26 11:49:03 -0800156 }
157
Ihab Awadcb387ac2014-05-28 16:49:38 -0700158 @Override
159 public void onRequestingRingback(Call call, boolean ringback) {
160 for (CallsManagerListener listener : mListeners) {
161 listener.onRequestingRingback(call, ringback);
162 }
163 }
164
Evan Charlton352105c2014-06-03 14:10:54 -0700165 @Override
166 public void onPostDialWait(Call call, String remaining) {
167 mInCallController.onPostDialWait(call, remaining);
168 }
169
Santos Cordona1610702014-06-04 20:22:56 -0700170 @Override
171 public void onExpiredConferenceCall(Call call) {
172 call.removeListener(this);
173 }
174
175 @Override
176 public void onConfirmedConferenceCall(Call call) {
177 addCall(call);
178 Log.v(this, "confirming Conf call %s", call);
179 for (CallsManagerListener listener : mListeners) {
180 listener.onIsConferencedChanged(call);
181 }
182 }
183
184 @Override
185 public void onParentChanged(Call call) {
186 for (CallsManagerListener listener : mListeners) {
187 listener.onIsConferencedChanged(call);
188 }
189 }
190
191 @Override
192 public void onChildrenChanged(Call call) {
193 for (CallsManagerListener listener : mListeners) {
194 listener.onIsConferencedChanged(call);
195 }
196 }
197
Ihab Awadff7493a2014-06-10 13:47:44 -0700198 @Override
Sailesh Nepal7e669572014-07-08 21:29:12 -0700199 public void onAudioModeIsVoipChanged(Call call) {
200 for (CallsManagerListener listener : mListeners) {
201 listener.onAudioModeIsVoipChanged(call);
202 }
203 }
204
Sailesh Nepal810735e2014-03-18 18:15:46 -0700205 ImmutableCollection<Call> getCalls() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700206 return ImmutableList.copyOf(mCalls);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700207 }
208
209 Call getForegroundCall() {
210 return mForegroundCall;
211 }
212
Santos Cordonae193062014-05-21 21:21:49 -0700213 Ringer getRinger() {
214 return mRinger;
215 }
216
Santos Cordonf3671a62014-05-29 21:51:53 -0700217 InCallController getInCallController() {
218 return mInCallController;
219 }
220
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700221 boolean hasEmergencyCall() {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700222 for (Call call : mCalls) {
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700223 if (call.isEmergencyCall()) {
224 return true;
225 }
226 }
227 return false;
228 }
229
230 CallAudioState getAudioState() {
231 return mCallAudioManager.getAudioState();
232 }
233
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800234 /**
Santos Cordon493e8f22014-02-19 03:15:12 -0800235 * Starts the incoming call sequence by having switchboard gather more information about the
236 * specified call; using the specified call service descriptor. Upon success, execution returns
Santos Cordon766d04f2014-05-06 10:28:25 -0700237 * to {@link #onSuccessfulIncomingCall} to start the in-call UI.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800238 *
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700239 * @param descriptor The descriptor of the connection service to use for this incoming call.
Evan Charltona05805b2014-03-05 08:21:46 -0800240 * @param extras The optional extras Bundle passed with the intent used for the incoming call.
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800241 */
Evan Charltona05805b2014-03-05 08:21:46 -0800242 void processIncomingCallIntent(CallServiceDescriptor descriptor, Bundle extras) {
Sailesh Nepalf1c191d2014-03-07 18:17:39 -0800243 Log.d(this, "processIncomingCallIntent");
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800244 // Create a call with no handle. Eventually, switchboard will update the call with
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700245 // additional information from the connection service, but for now we just need one to pass
Sailesh Nepale59bb192014-04-01 18:33:59 -0700246 // around.
Santos Cordona1610702014-06-04 20:22:56 -0700247 Call call = new Call(true /* isIncoming */, false /* isConference */);
Santos Cordon766d04f2014-05-06 10:28:25 -0700248 // TODO(santoscordon): Move this to be a part of addCall()
249 call.addListener(this);
Santos Cordon80d9bdc2014-02-13 18:28:46 -0800250
Santos Cordon766d04f2014-05-06 10:28:25 -0700251 call.startIncoming(descriptor, extras);
Ben Gilada0d9f752014-02-26 11:49:03 -0800252 }
253
254 /**
Yorke Lee33501632014-03-17 19:24:12 -0700255 * Attempts to issue/connect the specified call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800256 *
Yorke Lee33501632014-03-17 19:24:12 -0700257 * @param handle Handle to connect the call with.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800258 * @param contactInfo Information about the entity being called.
Yorke Lee33501632014-03-17 19:24:12 -0700259 * @param gatewayInfo Optional gateway information that can be used to route the call to the
Santos Cordon5b7b9b32014-03-26 14:00:22 -0700260 * actual dialed handle via a gateway provider. May be null.
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700261 * @param speakerphoneOn Whether or not to turn the speakerphone on once the call connects.
Tyler Gunnc4abd912014-07-08 14:22:10 -0700262 * @param videoState The desired video state for the outgoing call.
Santos Cordon8e8b8d22013-12-19 14:14:05 -0800263 */
Yorke Lee6f3f7af2014-07-11 10:59:46 -0700264 void placeOutgoingCall(Uri handle, GatewayInfo gatewayInfo, PhoneAccount account,
265 boolean speakerphoneOn, int videoState) {
Tyler Gunnc4abd912014-07-08 14:22:10 -0700266
Yorke Lee33501632014-03-17 19:24:12 -0700267 final Uri uriHandle = (gatewayInfo == null) ? handle : gatewayInfo.getGatewayHandle();
268
269 if (gatewayInfo == null) {
Santos Cordonb58f4532014-05-29 11:59:06 -0700270 Log.i(this, "Creating a new outgoing call with handle: %s", Log.piiHandle(uriHandle));
Yorke Lee33501632014-03-17 19:24:12 -0700271 } else {
272 Log.i(this, "Creating a new outgoing call with gateway handle: %s, original handle: %s",
273 Log.pii(uriHandle), Log.pii(handle));
274 }
Santos Cordon766d04f2014-05-06 10:28:25 -0700275
Santos Cordona1610702014-06-04 20:22:56 -0700276 Call call = new Call(
Ihab Awad98a55602014-06-30 21:27:28 -0700277 uriHandle, gatewayInfo, account,
Nancy Chen77d2d0e2014-06-24 12:06:03 -0700278 false /* isIncoming */, false /* isConference */);
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700279 call.setStartWithSpeakerphoneOn(speakerphoneOn);
Tyler Gunnc4abd912014-07-08 14:22:10 -0700280 call.setVideoState(videoState);
Santos Cordon766d04f2014-05-06 10:28:25 -0700281
282 // TODO(santoscordon): Move this to be a part of addCall()
283 call.addListener(this);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700284 addCall(call);
Santos Cordone3d76ab2014-01-28 17:25:20 -0800285
Santos Cordon766d04f2014-05-06 10:28:25 -0700286 call.startOutgoing();
Yorke Leef98fb572014-03-05 10:56:55 -0800287 }
288
289 /**
Santos Cordona1610702014-06-04 20:22:56 -0700290 * Attempts to start a conference call for the specified call.
291 *
292 * @param call The call to conference with.
293 */
294 void conference(Call call) {
295 Call conferenceCall = new Call(false, true);
296 conferenceCall.addListener(this);
297 call.conferenceInto(conferenceCall);
298 }
299
300 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800301 * Instructs Telecomm to answer the specified call. Intended to be invoked by the in-call
302 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
303 * the user opting to answer said call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800304 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700305 void answerCall(Call call) {
306 if (!mCalls.contains(call)) {
307 Log.i(this, "Request to answer a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800308 } else {
Santos Cordon40f78c22014-04-07 02:11:42 -0700309 // If the foreground call is not the ringing call and it is currently isActive() or
310 // DIALING, put it on hold before answering the call.
311 if (mForegroundCall != null && mForegroundCall != call &&
312 (mForegroundCall.isActive() ||
313 mForegroundCall.getState() == CallState.DIALING)) {
314 Log.v(this, "Holding active/dialing call %s before answering incoming call %s.",
315 mForegroundCall, call);
316 mForegroundCall.hold();
317 // TODO(santoscordon): Wait until we get confirmation of the active call being
318 // on-hold before answering the new call.
319 // TODO(santoscordon): Import logic from CallManager.acceptCall()
320 }
321
Santos Cordona56f2762014-03-24 15:55:53 -0700322 for (CallsManagerListener listener : mListeners) {
323 listener.onIncomingCallAnswered(call);
324 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800325
Santos Cordon61d0f702014-02-19 02:52:23 -0800326 // We do not update the UI until we get confirmation of the answer() through
Sailesh Nepale59bb192014-04-01 18:33:59 -0700327 // {@link #markCallAsActive}.
Santos Cordon61d0f702014-02-19 02:52:23 -0800328 call.answer();
329 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800330 }
331
332 /**
333 * Instructs Telecomm to reject the specified call. Intended to be invoked by the in-call
334 * app through {@link InCallAdapter} after Telecomm notifies it of an incoming call followed by
335 * the user opting to reject said call.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800336 */
Ihab Awadff7493a2014-06-10 13:47:44 -0700337 void rejectCall(Call call, boolean rejectWithMessage, String textMessage) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700338 if (!mCalls.contains(call)) {
339 Log.i(this, "Request to reject a non-existent call %s", call);
Santos Cordon61d0f702014-02-19 02:52:23 -0800340 } else {
Santos Cordona56f2762014-03-24 15:55:53 -0700341 for (CallsManagerListener listener : mListeners) {
Ihab Awadff7493a2014-06-10 13:47:44 -0700342 listener.onIncomingCallRejected(call, rejectWithMessage, textMessage);
Santos Cordona56f2762014-03-24 15:55:53 -0700343 }
Ihab Awadff7493a2014-06-10 13:47:44 -0700344 call.reject(rejectWithMessage, textMessage);
Santos Cordon61d0f702014-02-19 02:52:23 -0800345 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800346 }
347
348 /**
Ihab Awad74549ec2014-03-10 15:33:25 -0700349 * Instructs Telecomm to play the specified DTMF tone within the specified call.
350 *
Ihab Awad74549ec2014-03-10 15:33:25 -0700351 * @param digit The DTMF digit to play.
352 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700353 void playDtmfTone(Call call, char digit) {
354 if (!mCalls.contains(call)) {
355 Log.i(this, "Request to play DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700356 } else {
357 call.playDtmfTone(digit);
Santos Cordon92a2d812014-04-30 15:19:01 -0700358 mDtmfLocalTonePlayer.playTone(call, digit);
Ihab Awad74549ec2014-03-10 15:33:25 -0700359 }
360 }
361
362 /**
363 * Instructs Telecomm to stop the currently playing DTMF tone, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700364 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700365 void stopDtmfTone(Call call) {
366 if (!mCalls.contains(call)) {
367 Log.i(this, "Request to stop DTMF in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700368 } else {
369 call.stopDtmfTone();
Santos Cordon92a2d812014-04-30 15:19:01 -0700370 mDtmfLocalTonePlayer.stopTone(call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700371 }
372 }
373
374 /**
Evan Charlton352105c2014-06-03 14:10:54 -0700375 * Instructs Telecomm to continue (or not) the current post-dial DTMF string, if any.
Ihab Awad74549ec2014-03-10 15:33:25 -0700376 */
Evan Charlton352105c2014-06-03 14:10:54 -0700377 void postDialContinue(Call call, boolean proceed) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700378 if (!mCalls.contains(call)) {
379 Log.i(this, "Request to continue post-dial string in a non-existent call %s", call);
Ihab Awad74549ec2014-03-10 15:33:25 -0700380 } else {
Evan Charlton352105c2014-06-03 14:10:54 -0700381 call.postDialContinue(proceed);
Ihab Awad74549ec2014-03-10 15:33:25 -0700382 }
383 }
384
385 /**
Santos Cordone3d76ab2014-01-28 17:25:20 -0800386 * Instructs Telecomm to disconnect the specified call. Intended to be invoked by the
387 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
388 * the user hitting the end-call button.
Santos Cordone3d76ab2014-01-28 17:25:20 -0800389 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700390 void disconnectCall(Call call) {
Santos Cordon682fe6b2014-05-20 08:56:39 -0700391 Log.v(this, "disconnectCall %s", call);
392
Sailesh Nepale59bb192014-04-01 18:33:59 -0700393 if (!mCalls.contains(call)) {
394 Log.w(this, "Unknown call (%s) asked to disconnect", call);
Santos Cordon049b7b62014-01-30 05:34:26 -0800395 } else {
396 call.disconnect();
397 }
Santos Cordone3d76ab2014-01-28 17:25:20 -0800398 }
Santos Cordon681663d2014-01-30 04:32:15 -0800399
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700400 /**
401 * Instructs Telecomm to put the specified call on hold. Intended to be invoked by the
402 * in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered by
403 * the user hitting the hold button during an active call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700404 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700405 void holdCall(Call call) {
406 if (!mCalls.contains(call)) {
407 Log.w(this, "Unknown call (%s) asked to be put on hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700408 } else {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700409 Log.d(this, "Putting call on hold: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700410 call.hold();
411 }
412 }
413
414 /**
415 * Instructs Telecomm to release the specified call from hold. Intended to be invoked by
416 * the in-call app through {@link InCallAdapter} for an ongoing call. This is usually triggered
417 * by the user hitting the hold button during a held call.
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700418 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700419 void unholdCall(Call call) {
420 if (!mCalls.contains(call)) {
421 Log.w(this, "Unknown call (%s) asked to be removed from hold", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700422 } else {
Santos Cordonc7e85d42014-05-22 02:51:48 -0700423 Log.d(this, "unholding call: (%s)", call);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700424 call.unhold();
425 }
426 }
427
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700428 /** Called by the in-call UI to change the mute state. */
429 void mute(boolean shouldMute) {
430 mCallAudioManager.mute(shouldMute);
431 }
432
433 /**
434 * Called by the in-call UI to change the audio route, for example to change from earpiece to
435 * speaker phone.
436 */
437 void setAudioRoute(int route) {
438 mCallAudioManager.setAudioRoute(route);
439 }
440
Sailesh Nepal77da19e2014-07-02 21:31:16 -0700441 void phoneAccountClicked(Call call) {
442 if (!mCalls.contains(call)) {
443 Log.i(this, "phoneAccountClicked in a non-existent call %s", call);
444 } else {
445 call.phoneAccountClicked();
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700446 }
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700447 }
448
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700449 /** Called when the audio state changes. */
450 void onAudioStateChanged(CallAudioState oldAudioState, CallAudioState newAudioState) {
451 Log.v(this, "onAudioStateChanged, audioState: %s -> %s", oldAudioState, newAudioState);
Santos Cordona56f2762014-03-24 15:55:53 -0700452 for (CallsManagerListener listener : mListeners) {
453 listener.onAudioStateChanged(oldAudioState, newAudioState);
454 }
Sailesh Nepal6aca10a2014-03-24 16:11:02 -0700455 }
456
Sailesh Nepale59bb192014-04-01 18:33:59 -0700457 void markCallAsRinging(Call call) {
458 setCallState(call, CallState.RINGING);
Santos Cordon681663d2014-01-30 04:32:15 -0800459 }
460
Sailesh Nepale59bb192014-04-01 18:33:59 -0700461 void markCallAsDialing(Call call) {
462 setCallState(call, CallState.DIALING);
Santos Cordon681663d2014-01-30 04:32:15 -0800463 }
464
Sailesh Nepale59bb192014-04-01 18:33:59 -0700465 void markCallAsActive(Call call) {
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700466 if (call.getConnectTimeMillis() == 0) {
467 call.setConnectTimeMillis(System.currentTimeMillis());
468 }
Sailesh Nepale59bb192014-04-01 18:33:59 -0700469 setCallState(call, CallState.ACTIVE);
Sailesh Nepal84fa5f82014-04-02 11:01:11 -0700470
Sai Cheemalapatib7157e92014-06-11 17:51:55 -0700471 if (call.getStartWithSpeakerphoneOn()) {
472 setAudioRoute(CallAudioState.ROUTE_SPEAKER);
473 }
Santos Cordon681663d2014-01-30 04:32:15 -0800474 }
475
Sailesh Nepale59bb192014-04-01 18:33:59 -0700476 void markCallAsOnHold(Call call) {
477 setCallState(call, CallState.ON_HOLD);
Yorke Leecdf3ebd2014-03-12 18:31:41 -0700478 }
479
Santos Cordon049b7b62014-01-30 05:34:26 -0800480 /**
481 * Marks the specified call as DISCONNECTED and notifies the in-call app. If this was the last
482 * live call, then also disconnect from the in-call controller.
483 *
Santos Cordon79ff2bc2014-03-27 15:31:27 -0700484 * @param disconnectCause The disconnect reason, see {@link android.telephony.DisconnectCause}.
485 * @param disconnectMessage Optional call-service-provided message about the disconnect.
Santos Cordon049b7b62014-01-30 05:34:26 -0800486 */
Sailesh Nepale59bb192014-04-01 18:33:59 -0700487 void markCallAsDisconnected(Call call, int disconnectCause, String disconnectMessage) {
488 call.setDisconnectCause(disconnectCause, disconnectMessage);
489 setCallState(call, CallState.DISCONNECTED);
Sailesh Nepal77da19e2014-07-02 21:31:16 -0700490 removeCall(call);
Sailesh Nepal6ab6fb72014-04-01 20:03:19 -0700491 }
492
Ben Gilada0d9f752014-02-26 11:49:03 -0800493 /**
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700494 * Cleans up any calls currently associated with the specified connection service when the
Santos Cordon4b2c1192014-03-19 18:15:38 -0700495 * call-service binder disconnects unexpectedly.
496 *
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700497 * @param service The connection service that disconnected.
Santos Cordon4b2c1192014-03-19 18:15:38 -0700498 */
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700499 void handleConnectionServiceDeath(ConnectionServiceWrapper service) {
500 Preconditions.checkNotNull(service);
Sailesh Nepale59bb192014-04-01 18:33:59 -0700501 for (Call call : ImmutableList.copyOf(mCalls)) {
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700502 if (call.getConnectionService() == service) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700503 markCallAsDisconnected(call, DisconnectCause.ERROR_UNSPECIFIED, null);
Santos Cordon4b2c1192014-03-19 18:15:38 -0700504 }
505 }
506 }
507
Santos Cordondeb8c892014-05-30 01:38:03 -0700508 boolean hasAnyCalls() {
509 return !mCalls.isEmpty();
510 }
511
Santos Cordonc7e85d42014-05-22 02:51:48 -0700512 boolean hasActiveOrHoldingCall() {
Santos Cordon23baed32014-06-27 14:45:39 -0700513 return getFirstCallWithState(CallState.ACTIVE, CallState.ON_HOLD) != null;
Santos Cordonc7e85d42014-05-22 02:51:48 -0700514 }
515
516 boolean hasRingingCall() {
Santos Cordon23baed32014-06-27 14:45:39 -0700517 return getFirstCallWithState(CallState.RINGING) != null;
Santos Cordonc7e85d42014-05-22 02:51:48 -0700518 }
519
Santos Cordondeb8c892014-05-30 01:38:03 -0700520 boolean onMediaButton(int type) {
521 if (hasAnyCalls()) {
522 if (HeadsetMediaButton.SHORT_PRESS == type) {
523 Call ringingCall = getFirstCallWithState(CallState.RINGING);
524 if (ringingCall == null) {
525 mCallAudioManager.toggleMute();
526 return true;
527 } else {
528 ringingCall.answer();
529 return true;
530 }
531 } else if (HeadsetMediaButton.LONG_PRESS == type) {
532 Log.d(this, "handleHeadsetHook: longpress -> hangup");
533 Call callToHangup = getFirstCallWithState(
534 CallState.RINGING, CallState.DIALING, CallState.ACTIVE, CallState.ON_HOLD);
535 if (callToHangup != null) {
536 callToHangup.disconnect();
537 return true;
538 }
539 }
540 }
541 return false;
542 }
543
544 /**
Santos Cordon10838c22014-06-11 17:36:04 -0700545 * Checks to see if the specified call is the only high-level call and if so, enable the
546 * "Add-call" button. We allow you to add a second call but not a third or beyond.
547 *
548 * @param call The call to test for add-call.
549 * @return Whether the add-call feature should be enabled for the call.
550 */
551 protected boolean isAddCallCapable(Call call) {
552 if (call.getParentCall() != null) {
553 // Never true for child calls.
554 return false;
555 }
556
557 // Loop through all the other calls and there exists a top level (has no parent) call
558 // that is not the specified call, return false.
559 for (Call otherCall : mCalls) {
560 if (call != otherCall && otherCall.getParentCall() == null) {
561 return false;
562 }
563 }
564 return true;
565 }
566
567 /**
Santos Cordondeb8c892014-05-30 01:38:03 -0700568 * Returns the first call that it finds with the given states. The states are treated as having
569 * priority order so that any call with the first state will be returned before any call with
570 * states listed later in the parameter list.
571 */
Santos Cordon23baed32014-06-27 14:45:39 -0700572 Call getFirstCallWithState(CallState... states) {
Santos Cordondeb8c892014-05-30 01:38:03 -0700573 for (CallState currentState : states) {
Santos Cordon23baed32014-06-27 14:45:39 -0700574 // check the foreground first
575 if (mForegroundCall != null && mForegroundCall.getState() == currentState) {
576 return mForegroundCall;
577 }
578
Santos Cordondeb8c892014-05-30 01:38:03 -0700579 for (Call call : mCalls) {
580 if (currentState == call.getState()) {
581 return call;
582 }
583 }
584 }
585 return null;
586 }
587
Santos Cordon4b2c1192014-03-19 18:15:38 -0700588 /**
Ben Gilada0d9f752014-02-26 11:49:03 -0800589 * Adds the specified call to the main list of live calls.
590 *
591 * @param call The call to add.
592 */
593 private void addCall(Call call) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700594 mCalls.add(call);
Santos Cordon40f78c22014-04-07 02:11:42 -0700595
596 // TODO(santoscordon): Update mForegroundCall prior to invoking
597 // onCallAdded for calls which immediately take the foreground (like the first call).
Santos Cordona56f2762014-03-24 15:55:53 -0700598 for (CallsManagerListener listener : mListeners) {
599 listener.onCallAdded(call);
600 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700601 updateForegroundCall();
Ben Gilada0d9f752014-02-26 11:49:03 -0800602 }
603
Sailesh Nepal810735e2014-03-18 18:15:46 -0700604 private void removeCall(Call call) {
Santos Cordonc499c1c2014-04-14 17:13:14 -0700605 Log.v(this, "removeCall(%s)", call);
Sailesh Nepal4857f472014-04-07 22:26:27 -0700606
Santos Cordon766d04f2014-05-06 10:28:25 -0700607 call.removeListener(this);
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700608 call.clearConnectionService();
Sailesh Nepale59bb192014-04-01 18:33:59 -0700609
610 boolean shouldNotify = false;
611 if (mCalls.contains(call)) {
612 mCalls.remove(call);
613 shouldNotify = true;
Santos Cordona56f2762014-03-24 15:55:53 -0700614 }
Ben Gilada0d9f752014-02-26 11:49:03 -0800615
Sailesh Nepale59bb192014-04-01 18:33:59 -0700616 // Only broadcast changes for calls that are being tracked.
617 if (shouldNotify) {
618 for (CallsManagerListener listener : mListeners) {
619 listener.onCallRemoved(call);
620 }
621 updateForegroundCall();
Sailesh Nepal810735e2014-03-18 18:15:46 -0700622 }
623 }
Evan Charlton5c670a92014-03-06 14:58:20 -0800624
Sailesh Nepal810735e2014-03-18 18:15:46 -0700625 /**
Santos Cordon1ae2b852014-03-19 03:03:10 -0700626 * Sets the specified state on the specified call.
Sailesh Nepal810735e2014-03-18 18:15:46 -0700627 *
628 * @param call The call.
629 * @param newState The new state of the call.
630 */
631 private void setCallState(Call call, CallState newState) {
Sailesh Nepale59bb192014-04-01 18:33:59 -0700632 Preconditions.checkNotNull(newState);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700633 CallState oldState = call.getState();
Sailesh Nepal8c85dee2014-04-07 22:21:40 -0700634 Log.i(this, "setCallState %s -> %s, call: %s", oldState, newState, call);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700635 if (newState != oldState) {
636 // Unfortunately, in the telephony world the radio is king. So if the call notifies
637 // us that the call is in a particular state, we allow it even if it doesn't make
638 // sense (e.g., ACTIVE -> RINGING).
639 // TODO(santoscordon): Consider putting a stop to the above and turning CallState
640 // into a well-defined state machine.
641 // TODO(santoscordon): Define expected state transitions here, and log when an
642 // unexpected transition occurs.
643 call.setState(newState);
644
645 // Only broadcast state change for calls that are being tracked.
Sailesh Nepale59bb192014-04-01 18:33:59 -0700646 if (mCalls.contains(call)) {
Santos Cordona56f2762014-03-24 15:55:53 -0700647 for (CallsManagerListener listener : mListeners) {
648 listener.onCallStateChanged(call, oldState, newState);
649 }
Sailesh Nepal810735e2014-03-18 18:15:46 -0700650 updateForegroundCall();
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800651 }
652 }
653 }
654
655 /**
Sailesh Nepal810735e2014-03-18 18:15:46 -0700656 * Checks which call should be visible to the user and have audio focus.
Evan Charlton5c670a92014-03-06 14:58:20 -0800657 */
Sailesh Nepal810735e2014-03-18 18:15:46 -0700658 private void updateForegroundCall() {
659 Call newForegroundCall = null;
Sailesh Nepale59bb192014-04-01 18:33:59 -0700660 for (Call call : mCalls) {
Santos Cordon40f78c22014-04-07 02:11:42 -0700661 // TODO(santoscordon): Foreground-ness needs to be explicitly set. No call, regardless
Sailesh Nepalc92c4362014-07-04 18:33:21 -0700662 // of its state will be foreground by default and instead the connection service should
663 // be notified when its calls enter and exit foreground state. Foreground will mean that
Santos Cordon40f78c22014-04-07 02:11:42 -0700664 // the call should play audio and listen to microphone if it wants.
665
666 // Active calls have priority.
667 if (call.isActive()) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700668 newForegroundCall = call;
Evan Charlton5c670a92014-03-06 14:58:20 -0800669 break;
Sailesh Nepal810735e2014-03-18 18:15:46 -0700670 }
Santos Cordon40f78c22014-04-07 02:11:42 -0700671
672 if (call.isAlive() || call.getState() == CallState.RINGING) {
Sailesh Nepal810735e2014-03-18 18:15:46 -0700673 newForegroundCall = call;
Santos Cordon40f78c22014-04-07 02:11:42 -0700674 // Don't break in case there's an active call that has priority.
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800675 }
676 }
Santos Cordon4e9fffe2014-03-04 18:13:41 -0800677
Sailesh Nepal810735e2014-03-18 18:15:46 -0700678 if (newForegroundCall != mForegroundCall) {
Santos Cordon40f78c22014-04-07 02:11:42 -0700679 Log.v(this, "Updating foreground call, %s -> %s.", mForegroundCall, newForegroundCall);
Sailesh Nepal810735e2014-03-18 18:15:46 -0700680 Call oldForegroundCall = mForegroundCall;
681 mForegroundCall = newForegroundCall;
682
Santos Cordona56f2762014-03-24 15:55:53 -0700683 for (CallsManagerListener listener : mListeners) {
684 listener.onForegroundCallChanged(oldForegroundCall, mForegroundCall);
685 }
Santos Cordon681663d2014-01-30 04:32:15 -0800686 }
687 }
Ben Gilad9f2bed32013-12-12 17:43:26 -0800688}