1/*
2 * Copyright (C) 2006 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
17package com.android.phone;
18
19import com.android.internal.telephony.Call;
20import com.android.internal.telephony.CallManager;
21import com.android.internal.telephony.Connection;
22import com.android.internal.telephony.Phone;
23import com.android.internal.telephony.PhoneConstants;
24import com.android.internal.telephony.TelephonyCapabilities;
25import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaDisplayInfoRec;
26import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaSignalInfoRec;
27import com.android.internal.telephony.cdma.SignalToneUtil;
28
29import android.bluetooth.BluetoothAdapter;
30import android.bluetooth.BluetoothHeadset;
31import android.bluetooth.BluetoothProfile;
32import android.content.Context;
33import android.media.AudioAttributes;
34import android.media.AudioManager;
35import android.media.ToneGenerator;
36import android.os.AsyncResult;
37import android.os.Handler;
38import android.os.Message;
39import android.os.SystemProperties;
40import android.provider.Settings;
41import android.telecom.TelecomManager;
42import android.telephony.DisconnectCause;
43import android.telephony.PhoneNumberUtils;
44import android.telephony.PhoneStateListener;
45import android.telephony.SubscriptionInfo;
46import android.telephony.SubscriptionManager;
47import android.telephony.SubscriptionManager.OnSubscriptionsChangedListener;
48import android.telephony.TelephonyManager;
49import android.util.ArrayMap;
50import android.util.Log;
51
52import java.util.Iterator;
53import java.util.List;
54import java.util.Map;
55
56/**
57 * Phone app module that listens for phone state changes and various other
58 * events from the telephony layer, and triggers any resulting UI behavior
59 * (like starting the Incoming Call UI, playing in-call tones,
60 * updating notifications, writing call log entries, etc.)
61 */
62public class CallNotifier extends Handler {
63    private static final String LOG_TAG = "CallNotifier";
64    private static final boolean DBG =
65            (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
66    private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2);
67
68    // Time to display the message from the underlying phone layers.
69    private static final int SHOW_MESSAGE_NOTIFICATION_TIME = 3000; // msec
70
71    /** The singleton instance. */
72    private static CallNotifier sInstance;
73
74    private Map<Integer, CallNotifierPhoneStateListener> mPhoneStateListeners =
75            new ArrayMap<Integer, CallNotifierPhoneStateListener>();
76
77    private PhoneGlobals mApplication;
78    private CallManager mCM;
79    private BluetoothHeadset mBluetoothHeadset;
80
81    // ToneGenerator instance for playing SignalInfo tones
82    private ToneGenerator mSignalInfoToneGenerator;
83
84    // The tone volume relative to other sounds in the stream SignalInfo
85    private static final int TONE_RELATIVE_VOLUME_SIGNALINFO = 80;
86
87    private boolean mVoicePrivacyState = false;
88
89    // Cached AudioManager
90    private AudioManager mAudioManager;
91    private SubscriptionManager mSubscriptionManager;
92    private TelephonyManager mTelephonyManager;
93
94    // Events from the Phone object:
95    public static final int PHONE_DISCONNECT = 3;
96    public static final int PHONE_STATE_DISPLAYINFO = 6;
97    public static final int PHONE_STATE_SIGNALINFO = 7;
98    public static final int PHONE_ENHANCED_VP_ON = 9;
99    public static final int PHONE_ENHANCED_VP_OFF = 10;
100    public static final int PHONE_SUPP_SERVICE_FAILED = 14;
101    public static final int PHONE_TTY_MODE_RECEIVED = 15;
102    // Events generated internally.
103    // We should store all the possible event type values in one place to make sure that
104    // they don't step on each others' toes.
105    public static final int INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE = 22;
106    // Other events from call manager
107    public static final int EVENT_OTA_PROVISION_CHANGE = 20;
108
109    /**
110     * Initialize the singleton CallNotifier instance.
111     * This is only done once, at startup, from PhoneApp.onCreate().
112     */
113    /* package */ static CallNotifier init(
114            PhoneGlobals app) {
115        synchronized (CallNotifier.class) {
116            if (sInstance == null) {
117                sInstance = new CallNotifier(app);
118            } else {
119                Log.wtf(LOG_TAG, "init() called multiple times!  sInstance = " + sInstance);
120            }
121            return sInstance;
122        }
123    }
124
125    /** Private constructor; @see init() */
126    private CallNotifier(
127            PhoneGlobals app) {
128        mApplication = app;
129        mCM = app.mCM;
130
131        mAudioManager = (AudioManager) mApplication.getSystemService(Context.AUDIO_SERVICE);
132        mTelephonyManager =
133                (TelephonyManager) mApplication.getSystemService(Context.TELEPHONY_SERVICE);
134        mSubscriptionManager = (SubscriptionManager) mApplication.getSystemService(
135                Context.TELEPHONY_SUBSCRIPTION_SERVICE);
136
137        registerForNotifications();
138
139        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
140        if (adapter != null) {
141            adapter.getProfileProxy(mApplication.getApplicationContext(),
142                    mBluetoothProfileServiceListener,
143                    BluetoothProfile.HEADSET);
144        }
145
146        mSubscriptionManager.addOnSubscriptionsChangedListener(
147                new OnSubscriptionsChangedListener() {
148                    @Override
149                    public void onSubscriptionsChanged() {
150                        updatePhoneStateListeners();
151                    }
152                });
153    }
154
155    private void createSignalInfoToneGenerator() {
156        // Instantiate the ToneGenerator for SignalInfo and CallWaiting
157        // TODO: We probably don't need the mSignalInfoToneGenerator instance
158        // around forever. Need to change it so as to create a ToneGenerator instance only
159        // when a tone is being played and releases it after its done playing.
160        if (mSignalInfoToneGenerator == null) {
161            try {
162                mSignalInfoToneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL,
163                        TONE_RELATIVE_VOLUME_SIGNALINFO);
164                Log.d(LOG_TAG, "CallNotifier: mSignalInfoToneGenerator created when toneplay");
165            } catch (RuntimeException e) {
166                Log.w(LOG_TAG, "CallNotifier: Exception caught while creating " +
167                        "mSignalInfoToneGenerator: " + e);
168                mSignalInfoToneGenerator = null;
169            }
170        } else {
171            Log.d(LOG_TAG, "mSignalInfoToneGenerator created already, hence skipping");
172        }
173    }
174
175    /**
176     * Register for call state notifications with the CallManager.
177     */
178    private void registerForNotifications() {
179        mCM.registerForDisconnect(this, PHONE_DISCONNECT, null);
180        mCM.registerForCdmaOtaStatusChange(this, EVENT_OTA_PROVISION_CHANGE, null);
181        mCM.registerForDisplayInfo(this, PHONE_STATE_DISPLAYINFO, null);
182        mCM.registerForSignalInfo(this, PHONE_STATE_SIGNALINFO, null);
183        mCM.registerForInCallVoicePrivacyOn(this, PHONE_ENHANCED_VP_ON, null);
184        mCM.registerForInCallVoicePrivacyOff(this, PHONE_ENHANCED_VP_OFF, null);
185        mCM.registerForSuppServiceFailed(this, PHONE_SUPP_SERVICE_FAILED, null);
186        mCM.registerForTtyModeReceived(this, PHONE_TTY_MODE_RECEIVED, null);
187    }
188
189    @Override
190    public void handleMessage(Message msg) {
191        if (DBG) {
192            Log.d(LOG_TAG, "handleMessage(" + msg.what + ")");
193        }
194        switch (msg.what) {
195            case PHONE_DISCONNECT:
196                if (DBG) log("DISCONNECT");
197                // Stop any signalInfo tone being played when a call gets ended, the rest of the
198                // disconnect functionality in onDisconnect() is handled in ConnectionService.
199                stopSignalInfoTone();
200                break;
201
202            case PHONE_STATE_DISPLAYINFO:
203                if (DBG) log("Received PHONE_STATE_DISPLAYINFO event");
204                onDisplayInfo((AsyncResult) msg.obj);
205                break;
206
207            case PHONE_STATE_SIGNALINFO:
208                if (DBG) log("Received PHONE_STATE_SIGNALINFO event");
209                onSignalInfo((AsyncResult) msg.obj);
210                break;
211
212            case INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE:
213                if (DBG) log("Received Display Info notification done event ...");
214                PhoneDisplayMessage.dismissMessage();
215                break;
216
217            case EVENT_OTA_PROVISION_CHANGE:
218                if (DBG) log("EVENT_OTA_PROVISION_CHANGE...");
219                mApplication.handleOtaspEvent(msg);
220                break;
221
222            case PHONE_ENHANCED_VP_ON:
223                if (DBG) log("PHONE_ENHANCED_VP_ON...");
224                if (!mVoicePrivacyState) {
225                    int toneToPlay = InCallTonePlayer.TONE_VOICE_PRIVACY;
226                    new InCallTonePlayer(toneToPlay).start();
227                    mVoicePrivacyState = true;
228                }
229                break;
230
231            case PHONE_ENHANCED_VP_OFF:
232                if (DBG) log("PHONE_ENHANCED_VP_OFF...");
233                if (mVoicePrivacyState) {
234                    int toneToPlay = InCallTonePlayer.TONE_VOICE_PRIVACY;
235                    new InCallTonePlayer(toneToPlay).start();
236                    mVoicePrivacyState = false;
237                }
238                break;
239
240            case PHONE_SUPP_SERVICE_FAILED:
241                if (DBG) log("PHONE_SUPP_SERVICE_FAILED...");
242                onSuppServiceFailed((AsyncResult) msg.obj);
243                break;
244
245            case PHONE_TTY_MODE_RECEIVED:
246                if (DBG) log("Received PHONE_TTY_MODE_RECEIVED event");
247                onTtyModeReceived((AsyncResult) msg.obj);
248                break;
249
250            default:
251                // super.handleMessage(msg);
252        }
253    }
254
255    void updateCallNotifierRegistrationsAfterRadioTechnologyChange() {
256        if (DBG) Log.d(LOG_TAG, "updateCallNotifierRegistrationsAfterRadioTechnologyChange...");
257
258        // Instantiate mSignalInfoToneGenerator
259        createSignalInfoToneGenerator();
260    }
261
262    /**
263     * Resets the audio mode and speaker state when a call ends.
264     */
265    private void resetAudioStateAfterDisconnect() {
266        if (VDBG) log("resetAudioStateAfterDisconnect()...");
267
268        if (mBluetoothHeadset != null) {
269            mBluetoothHeadset.disconnectAudio();
270        }
271
272        // call turnOnSpeaker() with state=false and store=true even if speaker
273        // is already off to reset user requested speaker state.
274        PhoneUtils.turnOnSpeaker(mApplication, false, true);
275
276        PhoneUtils.setAudioMode(mCM);
277    }
278
279    /**
280     * Helper class to play tones through the earpiece (or speaker / BT)
281     * during a call, using the ToneGenerator.
282     *
283     * To use, just instantiate a new InCallTonePlayer
284     * (passing in the TONE_* constant for the tone you want)
285     * and start() it.
286     *
287     * When we're done playing the tone, if the phone is idle at that
288     * point, we'll reset the audio routing and speaker state.
289     * (That means that for tones that get played *after* a call
290     * disconnects, like "busy" or "congestion" or "call ended", you
291     * should NOT call resetAudioStateAfterDisconnect() yourself.
292     * Instead, just start the InCallTonePlayer, which will automatically
293     * defer the resetAudioStateAfterDisconnect() call until the tone
294     * finishes playing.)
295     */
296    private class InCallTonePlayer extends Thread {
297        private int mToneId;
298        private int mState;
299        // The possible tones we can play.
300        public static final int TONE_NONE = 0;
301        public static final int TONE_CALL_WAITING = 1;
302        public static final int TONE_BUSY = 2;
303        public static final int TONE_CONGESTION = 3;
304        public static final int TONE_CALL_ENDED = 4;
305        public static final int TONE_VOICE_PRIVACY = 5;
306        public static final int TONE_REORDER = 6;
307        public static final int TONE_INTERCEPT = 7;
308        public static final int TONE_CDMA_DROP = 8;
309        public static final int TONE_OUT_OF_SERVICE = 9;
310        public static final int TONE_REDIAL = 10;
311        public static final int TONE_OTA_CALL_END = 11;
312        public static final int TONE_UNOBTAINABLE_NUMBER = 13;
313
314        // The tone volume relative to other sounds in the stream
315        static final int TONE_RELATIVE_VOLUME_EMERGENCY = 100;
316        static final int TONE_RELATIVE_VOLUME_HIPRI = 80;
317        static final int TONE_RELATIVE_VOLUME_LOPRI = 50;
318
319        // Buffer time (in msec) to add on to tone timeout value.
320        // Needed mainly when the timeout value for a tone is the
321        // exact duration of the tone itself.
322        static final int TONE_TIMEOUT_BUFFER = 20;
323
324        // The tone state
325        static final int TONE_OFF = 0;
326        static final int TONE_ON = 1;
327        static final int TONE_STOPPED = 2;
328
329        InCallTonePlayer(int toneId) {
330            super();
331            mToneId = toneId;
332            mState = TONE_OFF;
333        }
334
335        @Override
336        public void run() {
337            log("InCallTonePlayer.run(toneId = " + mToneId + ")...");
338
339            int toneType = 0;  // passed to ToneGenerator.startTone()
340            int toneVolume;  // passed to the ToneGenerator constructor
341            int toneLengthMillis;
342            int phoneType = mCM.getFgPhone().getPhoneType();
343
344            switch (mToneId) {
345                case TONE_CALL_WAITING:
346                    toneType = ToneGenerator.TONE_SUP_CALL_WAITING;
347                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
348                    // Call waiting tone is stopped by stopTone() method
349                    toneLengthMillis = Integer.MAX_VALUE - TONE_TIMEOUT_BUFFER;
350                    break;
351                case TONE_BUSY:
352                    if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
353                        toneType = ToneGenerator.TONE_CDMA_NETWORK_BUSY_ONE_SHOT;
354                        toneVolume = TONE_RELATIVE_VOLUME_LOPRI;
355                        toneLengthMillis = 1000;
356                    } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM
357                            || phoneType == PhoneConstants.PHONE_TYPE_SIP
358                            || phoneType == PhoneConstants.PHONE_TYPE_IMS
359                            || phoneType == PhoneConstants.PHONE_TYPE_THIRD_PARTY) {
360                        toneType = ToneGenerator.TONE_SUP_BUSY;
361                        toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
362                        toneLengthMillis = 4000;
363                    } else {
364                        throw new IllegalStateException("Unexpected phone type: " + phoneType);
365                    }
366                    break;
367                case TONE_CONGESTION:
368                    toneType = ToneGenerator.TONE_SUP_CONGESTION;
369                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
370                    toneLengthMillis = 4000;
371                    break;
372
373                case TONE_CALL_ENDED:
374                    toneType = ToneGenerator.TONE_PROP_PROMPT;
375                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
376                    toneLengthMillis = 200;
377                    break;
378                 case TONE_OTA_CALL_END:
379                    if (mApplication.cdmaOtaConfigData.otaPlaySuccessFailureTone ==
380                            OtaUtils.OTA_PLAY_SUCCESS_FAILURE_TONE_ON) {
381                        toneType = ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD;
382                        toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
383                        toneLengthMillis = 750;
384                    } else {
385                        toneType = ToneGenerator.TONE_PROP_PROMPT;
386                        toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
387                        toneLengthMillis = 200;
388                    }
389                    break;
390                case TONE_VOICE_PRIVACY:
391                    toneType = ToneGenerator.TONE_CDMA_ALERT_NETWORK_LITE;
392                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
393                    toneLengthMillis = 5000;
394                    break;
395                case TONE_REORDER:
396                    toneType = ToneGenerator.TONE_CDMA_REORDER;
397                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
398                    toneLengthMillis = 4000;
399                    break;
400                case TONE_INTERCEPT:
401                    toneType = ToneGenerator.TONE_CDMA_ABBR_INTERCEPT;
402                    toneVolume = TONE_RELATIVE_VOLUME_LOPRI;
403                    toneLengthMillis = 500;
404                    break;
405                case TONE_CDMA_DROP:
406                case TONE_OUT_OF_SERVICE:
407                    toneType = ToneGenerator.TONE_CDMA_CALLDROP_LITE;
408                    toneVolume = TONE_RELATIVE_VOLUME_LOPRI;
409                    toneLengthMillis = 375;
410                    break;
411                case TONE_REDIAL:
412                    toneType = ToneGenerator.TONE_CDMA_ALERT_AUTOREDIAL_LITE;
413                    toneVolume = TONE_RELATIVE_VOLUME_LOPRI;
414                    toneLengthMillis = 5000;
415                    break;
416                case TONE_UNOBTAINABLE_NUMBER:
417                    toneType = ToneGenerator.TONE_SUP_ERROR;
418                    toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
419                    toneLengthMillis = 4000;
420                    break;
421                default:
422                    throw new IllegalArgumentException("Bad toneId: " + mToneId);
423            }
424
425            // If the mToneGenerator creation fails, just continue without it.  It is
426            // a local audio signal, and is not as important.
427            ToneGenerator toneGenerator;
428            try {
429                int stream;
430                if (mBluetoothHeadset != null) {
431                    stream = mBluetoothHeadset.isAudioOn() ? AudioManager.STREAM_BLUETOOTH_SCO:
432                        AudioManager.STREAM_VOICE_CALL;
433                } else {
434                    stream = AudioManager.STREAM_VOICE_CALL;
435                }
436                toneGenerator = new ToneGenerator(stream, toneVolume);
437                // if (DBG) log("- created toneGenerator: " + toneGenerator);
438            } catch (RuntimeException e) {
439                Log.w(LOG_TAG,
440                      "InCallTonePlayer: Exception caught while creating ToneGenerator: " + e);
441                toneGenerator = null;
442            }
443
444            // Using the ToneGenerator (with the CALL_WAITING / BUSY /
445            // CONGESTION tones at least), the ToneGenerator itself knows
446            // the right pattern of tones to play; we do NOT need to
447            // manually start/stop each individual tone, or manually
448            // insert the correct delay between tones.  (We just start it
449            // and let it run for however long we want the tone pattern to
450            // continue.)
451            //
452            // TODO: When we stop the ToneGenerator in the middle of a
453            // "tone pattern", it sounds bad if we cut if off while the
454            // tone is actually playing.  Consider adding API to the
455            // ToneGenerator to say "stop at the next silent part of the
456            // pattern", or simply "play the pattern N times and then
457            // stop."
458            boolean needToStopTone = true;
459            boolean okToPlayTone = false;
460
461            if (toneGenerator != null) {
462                int ringerMode = mAudioManager.getRingerMode();
463                if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
464                    if (toneType == ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD) {
465                        if ((ringerMode != AudioManager.RINGER_MODE_SILENT) &&
466                                (ringerMode != AudioManager.RINGER_MODE_VIBRATE)) {
467                            if (DBG) log("- InCallTonePlayer: start playing call tone=" + toneType);
468                            okToPlayTone = true;
469                            needToStopTone = false;
470                        }
471                    } else if ((toneType == ToneGenerator.TONE_CDMA_NETWORK_BUSY_ONE_SHOT) ||
472                            (toneType == ToneGenerator.TONE_CDMA_REORDER) ||
473                            (toneType == ToneGenerator.TONE_CDMA_ABBR_REORDER) ||
474                            (toneType == ToneGenerator.TONE_CDMA_ABBR_INTERCEPT) ||
475                            (toneType == ToneGenerator.TONE_CDMA_CALLDROP_LITE)) {
476                        if (ringerMode != AudioManager.RINGER_MODE_SILENT) {
477                            if (DBG) log("InCallTonePlayer:playing call fail tone:" + toneType);
478                            okToPlayTone = true;
479                            needToStopTone = false;
480                        }
481                    } else if ((toneType == ToneGenerator.TONE_CDMA_ALERT_AUTOREDIAL_LITE) ||
482                               (toneType == ToneGenerator.TONE_CDMA_ALERT_NETWORK_LITE)) {
483                        if ((ringerMode != AudioManager.RINGER_MODE_SILENT) &&
484                                (ringerMode != AudioManager.RINGER_MODE_VIBRATE)) {
485                            if (DBG) log("InCallTonePlayer:playing tone for toneType=" + toneType);
486                            okToPlayTone = true;
487                            needToStopTone = false;
488                        }
489                    } else { // For the rest of the tones, always OK to play.
490                        okToPlayTone = true;
491                    }
492                } else {  // Not "CDMA"
493                    okToPlayTone = true;
494                }
495
496                synchronized (this) {
497                    if (okToPlayTone && mState != TONE_STOPPED) {
498                        mState = TONE_ON;
499                        toneGenerator.startTone(toneType);
500                        try {
501                            wait(toneLengthMillis + TONE_TIMEOUT_BUFFER);
502                        } catch  (InterruptedException e) {
503                            Log.w(LOG_TAG,
504                                  "InCallTonePlayer stopped: " + e);
505                        }
506                        if (needToStopTone) {
507                            toneGenerator.stopTone();
508                        }
509                    }
510                    // if (DBG) log("- InCallTonePlayer: done playing.");
511                    toneGenerator.release();
512                    mState = TONE_OFF;
513                }
514            }
515
516            // Finally, do the same cleanup we otherwise would have done
517            // in onDisconnect().
518            //
519            // (But watch out: do NOT do this if the phone is in use,
520            // since some of our tones get played *during* a call (like
521            // CALL_WAITING) and we definitely *don't*
522            // want to reset the audio mode / speaker / bluetooth after
523            // playing those!
524            // This call is really here for use with tones that get played
525            // *after* a call disconnects, like "busy" or "congestion" or
526            // "call ended", where the phone has already become idle but
527            // we need to defer the resetAudioStateAfterDisconnect() call
528            // till the tone finishes playing.)
529            if (mCM.getState() == PhoneConstants.State.IDLE) {
530                resetAudioStateAfterDisconnect();
531            }
532        }
533    }
534
535    /**
536     * Displays a notification when the phone receives a DisplayInfo record.
537     */
538    private void onDisplayInfo(AsyncResult r) {
539        // Extract the DisplayInfo String from the message
540        CdmaDisplayInfoRec displayInfoRec = (CdmaDisplayInfoRec)(r.result);
541
542        if (displayInfoRec != null) {
543            String displayInfo = displayInfoRec.alpha;
544            if (DBG) log("onDisplayInfo: displayInfo=" + displayInfo);
545            PhoneDisplayMessage.displayNetworkMessage(mApplication, displayInfo);
546
547            // start a timer that kills the dialog
548            sendEmptyMessageDelayed(INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE,
549                    SHOW_MESSAGE_NOTIFICATION_TIME);
550        }
551    }
552
553    /**
554     * Displays a notification when the phone receives a notice that a supplemental
555     * service has failed.
556     * TODO: This is a NOOP if it isn't for conferences or resuming call failures right now.
557     */
558    private void onSuppServiceFailed(AsyncResult r) {
559        if (r.result != Phone.SuppService.CONFERENCE && r.result != Phone.SuppService.RESUME) {
560            if (DBG) log("onSuppServiceFailed: not a merge or resume failure event");
561            return;
562        }
563
564        String mergeFailedString = "";
565        if (r.result == Phone.SuppService.CONFERENCE) {
566            if (DBG) log("onSuppServiceFailed: displaying merge failure message");
567            mergeFailedString = mApplication.getResources().getString(
568                    R.string.incall_error_supp_service_conference);
569        } else if (r.result == Phone.SuppService.RESUME) {
570            if (DBG) log("onSuppServiceFailed: displaying merge failure message");
571            mergeFailedString = mApplication.getResources().getString(
572                    R.string.incall_error_supp_service_switch);
573        } else if (r.result == Phone.SuppService.HOLD) {
574            mergeFailedString = mApplication.getResources().getString(
575                    R.string.incall_error_supp_service_hold);
576        }
577        PhoneDisplayMessage.displayErrorMessage(mApplication, mergeFailedString);
578
579        // start a timer that kills the dialog
580        sendEmptyMessageDelayed(INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE,
581                SHOW_MESSAGE_NOTIFICATION_TIME);
582    }
583
584    public void updatePhoneStateListeners() {
585        List<SubscriptionInfo> subInfos = mSubscriptionManager.getActiveSubscriptionInfoList();
586
587        // Unregister phone listeners for inactive subscriptions.
588        Iterator<Integer> itr = mPhoneStateListeners.keySet().iterator();
589        while (itr.hasNext()) {
590            int subId = itr.next();
591            if (subInfos == null || !containsSubId(subInfos, subId)) {
592                // Hide the outstanding notifications.
593                mApplication.notificationMgr.updateMwi(subId, false);
594                mApplication.notificationMgr.updateCfi(subId, false);
595
596                // Listening to LISTEN_NONE removes the listener.
597                mTelephonyManager.listen(
598                        mPhoneStateListeners.get(subId), PhoneStateListener.LISTEN_NONE);
599                itr.remove();
600            }
601        }
602
603        if (subInfos == null) {
604            return;
605        }
606
607        // Register new phone listeners for active subscriptions.
608        for (int i = 0; i < subInfos.size(); i++) {
609            int subId = subInfos.get(i).getSubscriptionId();
610            if (!mPhoneStateListeners.containsKey(subId)) {
611                CallNotifierPhoneStateListener listener = new CallNotifierPhoneStateListener(subId);
612                mTelephonyManager.listen(listener,
613                        PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR
614                        | PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR);
615                mPhoneStateListeners.put(subId, listener);
616            }
617        }
618    }
619
620    /**
621     * @return {@code true} if the list contains SubscriptionInfo with the given subscription id.
622     */
623    private boolean containsSubId(List<SubscriptionInfo> subInfos, int subId) {
624        if (subInfos == null) {
625            return false;
626        }
627
628        for (int i = 0; i < subInfos.size(); i++) {
629            if (subInfos.get(i).getSubscriptionId() == subId) {
630                return true;
631            }
632        }
633        return false;
634    }
635
636    /**
637     * Displays a notification when the phone receives a notice that TTY mode
638     * has changed on remote end.
639     */
640    private void onTtyModeReceived(AsyncResult r) {
641        if (DBG) log("TtyModeReceived: displaying notification message");
642
643        int resId = 0;
644        switch (((Integer)r.result).intValue()) {
645            case TelecomManager.TTY_MODE_FULL:
646                resId = com.android.internal.R.string.peerTtyModeFull;
647                break;
648            case TelecomManager.TTY_MODE_HCO:
649                resId = com.android.internal.R.string.peerTtyModeHco;
650                break;
651            case TelecomManager.TTY_MODE_VCO:
652                resId = com.android.internal.R.string.peerTtyModeVco;
653                break;
654            case TelecomManager.TTY_MODE_OFF:
655                resId = com.android.internal.R.string.peerTtyModeOff;
656                break;
657            default:
658                Log.e(LOG_TAG, "Unsupported TTY mode: " + r.result);
659                break;
660        }
661        if (resId != 0) {
662            PhoneDisplayMessage.displayNetworkMessage(mApplication,
663                    mApplication.getResources().getString(resId));
664
665            // start a timer that kills the dialog
666            sendEmptyMessageDelayed(INTERNAL_SHOW_MESSAGE_NOTIFICATION_DONE,
667                    SHOW_MESSAGE_NOTIFICATION_TIME);
668        }
669    }
670
671    /**
672     * Helper class to play SignalInfo tones using the ToneGenerator.
673     *
674     * To use, just instantiate a new SignalInfoTonePlayer
675     * (passing in the ToneID constant for the tone you want)
676     * and start() it.
677     */
678    private class SignalInfoTonePlayer extends Thread {
679        private int mToneId;
680
681        SignalInfoTonePlayer(int toneId) {
682            super();
683            mToneId = toneId;
684        }
685
686        @Override
687        public void run() {
688            log("SignalInfoTonePlayer.run(toneId = " + mToneId + ")...");
689            createSignalInfoToneGenerator();
690            if (mSignalInfoToneGenerator != null) {
691                //First stop any ongoing SignalInfo tone
692                mSignalInfoToneGenerator.stopTone();
693
694                //Start playing the new tone if its a valid tone
695                mSignalInfoToneGenerator.startTone(mToneId);
696            }
697        }
698    }
699
700    /**
701     * Plays a tone when the phone receives a SignalInfo record.
702     */
703    private void onSignalInfo(AsyncResult r) {
704        // Signal Info are totally ignored on non-voice-capable devices.
705        if (!PhoneGlobals.sVoiceCapable) {
706            Log.w(LOG_TAG, "Got onSignalInfo() on non-voice-capable device! Ignoring...");
707            return;
708        }
709
710        if (PhoneUtils.isRealIncomingCall(mCM.getFirstActiveRingingCall().getState())) {
711            // Do not start any new SignalInfo tone when Call state is INCOMING
712            // and stop any previous SignalInfo tone which is being played
713            stopSignalInfoTone();
714        } else {
715            // Extract the SignalInfo String from the message
716            CdmaSignalInfoRec signalInfoRec = (CdmaSignalInfoRec)(r.result);
717            // Only proceed if a Signal info is present.
718            if (signalInfoRec != null) {
719                boolean isPresent = signalInfoRec.isPresent;
720                if (DBG) log("onSignalInfo: isPresent=" + isPresent);
721                if (isPresent) {// if tone is valid
722                    int uSignalType = signalInfoRec.signalType;
723                    int uAlertPitch = signalInfoRec.alertPitch;
724                    int uSignal = signalInfoRec.signal;
725
726                    if (DBG) log("onSignalInfo: uSignalType=" + uSignalType + ", uAlertPitch=" +
727                            uAlertPitch + ", uSignal=" + uSignal);
728                    //Map the Signal to a ToneGenerator ToneID only if Signal info is present
729                    int toneID = SignalToneUtil.getAudioToneFromSignalInfo
730                            (uSignalType, uAlertPitch, uSignal);
731
732                    //Create the SignalInfo tone player and pass the ToneID
733                    new SignalInfoTonePlayer(toneID).start();
734                }
735            }
736        }
737    }
738
739    /**
740     * Stops a SignalInfo tone in the following condition
741     * 1 - On receiving a New Ringing Call
742     * 2 - On disconnecting a call
743     * 3 - On answering a Call Waiting Call
744     */
745    /* package */ void stopSignalInfoTone() {
746        if (DBG) log("stopSignalInfoTone: Stopping SignalInfo tone player");
747        new SignalInfoTonePlayer(ToneGenerator.TONE_CDMA_SIGNAL_OFF).start();
748    }
749
750    private BluetoothProfile.ServiceListener mBluetoothProfileServiceListener =
751           new BluetoothProfile.ServiceListener() {
752                public void onServiceConnected(int profile, BluetoothProfile proxy) {
753                    mBluetoothHeadset = (BluetoothHeadset) proxy;
754                    if (VDBG) log("- Got BluetoothHeadset: " + mBluetoothHeadset);
755                }
756
757                public void onServiceDisconnected(int profile) {
758                    mBluetoothHeadset = null;
759                }
760            };
761
762    private class CallNotifierPhoneStateListener extends PhoneStateListener {
763        public CallNotifierPhoneStateListener(int subId) {
764            super(subId);
765        }
766
767        @Override
768        public void onMessageWaitingIndicatorChanged(boolean visible) {
769            if (VDBG) log("onMessageWaitingIndicatorChanged(): " + this.mSubId + " " + visible);
770            mApplication.notificationMgr.updateMwi(this.mSubId, visible);
771        }
772
773        @Override
774        public void onCallForwardingIndicatorChanged(boolean visible) {
775            if (VDBG) log("onCallForwardingIndicatorChanged(): " + this.mSubId + " " + visible);
776            mApplication.notificationMgr.updateCfi(this.mSubId, visible);
777        }
778    };
779
780    private void log(String msg) {
781        Log.d(LOG_TAG, msg);
782    }
783}
784