| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License |
| */ |
| |
| package com.android.incallui; |
| |
| import static com.android.contacts.common.compat.CallCompat.Details.PROPERTY_ENTERPRISE_CALL; |
| |
| import android.Manifest; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.graphics.drawable.Drawable; |
| import android.hardware.display.DisplayManager; |
| import android.os.BatteryManager; |
| import android.os.Handler; |
| import android.os.Trace; |
| import android.support.annotation.NonNull; |
| import android.support.annotation.Nullable; |
| import android.support.v4.app.Fragment; |
| import android.support.v4.content.ContextCompat; |
| import android.telecom.Call.Details; |
| import android.telecom.StatusHints; |
| import android.telecom.TelecomManager; |
| import android.text.BidiFormatter; |
| import android.text.TextDirectionHeuristics; |
| import android.text.TextUtils; |
| import android.view.Display; |
| import android.view.View; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.accessibility.AccessibilityManager; |
| import com.android.contacts.common.ContactsUtils; |
| import com.android.dialer.common.Assert; |
| import com.android.dialer.common.LogUtil; |
| import com.android.dialer.configprovider.ConfigProviderComponent; |
| import com.android.dialer.contacts.ContactsComponent; |
| import com.android.dialer.logging.DialerImpression; |
| import com.android.dialer.logging.Logger; |
| import com.android.dialer.multimedia.MultimediaData; |
| import com.android.dialer.oem.MotorolaUtils; |
| import com.android.dialer.phonenumberutil.PhoneNumberHelper; |
| import com.android.dialer.postcall.PostCall; |
| import com.android.dialer.preferredsim.suggestion.SuggestionProvider; |
| import com.android.incallui.ContactInfoCache.ContactCacheEntry; |
| import com.android.incallui.ContactInfoCache.ContactInfoCacheCallback; |
| import com.android.incallui.InCallPresenter.InCallDetailsListener; |
| import com.android.incallui.InCallPresenter.InCallEventListener; |
| import com.android.incallui.InCallPresenter.InCallState; |
| import com.android.incallui.InCallPresenter.InCallStateListener; |
| import com.android.incallui.InCallPresenter.IncomingCallListener; |
| import com.android.incallui.call.CallList; |
| import com.android.incallui.call.DialerCall; |
| import com.android.incallui.call.DialerCallListener; |
| import com.android.incallui.call.state.DialerCallState; |
| import com.android.incallui.calllocation.CallLocation; |
| import com.android.incallui.calllocation.CallLocationComponent; |
| import com.android.incallui.incall.protocol.ContactPhotoType; |
| import com.android.incallui.incall.protocol.InCallScreen; |
| import com.android.incallui.incall.protocol.InCallScreenDelegate; |
| import com.android.incallui.incall.protocol.PrimaryCallState; |
| import com.android.incallui.incall.protocol.PrimaryCallState.ButtonState; |
| import com.android.incallui.incall.protocol.PrimaryInfo; |
| import com.android.incallui.incall.protocol.SecondaryInfo; |
| import com.android.incallui.videotech.utils.SessionModificationState; |
| import java.lang.ref.WeakReference; |
| |
| /** |
| * Controller for the Call Card Fragment. This class listens for changes to InCallState and passes |
| * it along to the fragment. |
| */ |
| public class CallCardPresenter |
| implements InCallStateListener, |
| IncomingCallListener, |
| InCallDetailsListener, |
| InCallEventListener, |
| InCallScreenDelegate, |
| DialerCallListener { |
| |
| /** |
| * Amount of time to wait before sending an announcement via the accessibility manager. When the |
| * call state changes to an outgoing or incoming state for the first time, the UI can often be |
| * changing due to call updates or contact lookup. This allows the UI to settle to a stable state |
| * to ensure that the correct information is announced. |
| */ |
| private static final long ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS = 500; |
| |
| /** Flag to allow the user's current location to be shown during emergency calls. */ |
| private static final String CONFIG_ENABLE_EMERGENCY_LOCATION = "config_enable_emergency_location"; |
| |
| private static final boolean CONFIG_ENABLE_EMERGENCY_LOCATION_DEFAULT = true; |
| |
| /** |
| * Make it possible to not get location during an emergency call if the battery is too low, since |
| * doing so could trigger gps and thus potentially cause the phone to die in the middle of the |
| * call. |
| */ |
| private static final String CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION = |
| "min_battery_percent_for_emergency_location"; |
| |
| private static final long CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT = 10; |
| |
| private final Context context; |
| private final Handler handler = new Handler(); |
| |
| private DialerCall primary; |
| private String primaryNumber; |
| private DialerCall secondary; |
| private String secondaryNumber; |
| private ContactCacheEntry primaryContactInfo; |
| private ContactCacheEntry secondaryContactInfo; |
| private boolean isFullscreen = false; |
| private InCallScreen inCallScreen; |
| private boolean isInCallScreenReady; |
| private boolean shouldSendAccessibilityEvent; |
| |
| @NonNull private final CallLocation callLocation; |
| private final Runnable sendAccessibilityEventRunnable = |
| new Runnable() { |
| @Override |
| public void run() { |
| shouldSendAccessibilityEvent = !sendAccessibilityEvent(context, getUi()); |
| LogUtil.i( |
| "CallCardPresenter.sendAccessibilityEventRunnable", |
| "still should send: %b", |
| shouldSendAccessibilityEvent); |
| if (!shouldSendAccessibilityEvent) { |
| handler.removeCallbacks(this); |
| } |
| } |
| }; |
| |
| public CallCardPresenter(Context context) { |
| LogUtil.i("CallCardPresenter.constructor", null); |
| this.context = Assert.isNotNull(context).getApplicationContext(); |
| callLocation = CallLocationComponent.get(this.context).getCallLocation(); |
| } |
| |
| private static boolean hasCallSubject(DialerCall call) { |
| return !TextUtils.isEmpty(call.getCallSubject()); |
| } |
| |
| @Override |
| public void onInCallScreenDelegateInit(InCallScreen inCallScreen) { |
| Assert.isNotNull(inCallScreen); |
| this.inCallScreen = inCallScreen; |
| |
| // Call may be null if disconnect happened already. |
| DialerCall call = CallList.getInstance().getFirstCall(); |
| if (call != null) { |
| primary = call; |
| if (shouldShowNoteSentToast(primary)) { |
| this.inCallScreen.showNoteSentToast(); |
| } |
| call.addListener(this); |
| // start processing lookups right away. |
| if (!call.isConferenceCall()) { |
| startContactInfoSearch(call, true, call.getState() == DialerCallState.INCOMING); |
| } else { |
| updateContactEntry(null, true); |
| } |
| } |
| |
| onStateChange(null, InCallPresenter.getInstance().getInCallState(), CallList.getInstance()); |
| } |
| |
| @Override |
| public void onInCallScreenReady() { |
| LogUtil.i("CallCardPresenter.onInCallScreenReady", null); |
| Assert.checkState(!isInCallScreenReady); |
| |
| // Contact search may have completed before ui is ready. |
| if (primaryContactInfo != null) { |
| updatePrimaryDisplayInfo(); |
| } |
| |
| // Register for call state changes last |
| InCallPresenter.getInstance().addListener(this); |
| InCallPresenter.getInstance().addIncomingCallListener(this); |
| InCallPresenter.getInstance().addDetailsListener(this); |
| InCallPresenter.getInstance().addInCallEventListener(this); |
| isInCallScreenReady = true; |
| |
| // Log location impressions |
| if (isOutgoingEmergencyCall(primary)) { |
| Logger.get(context).logImpression(DialerImpression.Type.EMERGENCY_NEW_EMERGENCY_CALL); |
| } else if (isIncomingEmergencyCall(primary) || isIncomingEmergencyCall(secondary)) { |
| Logger.get(context).logImpression(DialerImpression.Type.EMERGENCY_CALLBACK); |
| } |
| |
| // Showing the location may have been skipped if the UI wasn't ready during previous layout. |
| if (shouldShowLocation()) { |
| inCallScreen.showLocationUi(getLocationFragment()); |
| |
| // Log location impressions |
| if (!hasLocationPermission()) { |
| Logger.get(context).logImpression(DialerImpression.Type.EMERGENCY_NO_LOCATION_PERMISSION); |
| } else if (isBatteryTooLowForEmergencyLocation()) { |
| Logger.get(context) |
| .logImpression(DialerImpression.Type.EMERGENCY_BATTERY_TOO_LOW_TO_GET_LOCATION); |
| } else if (!callLocation.canGetLocation(context)) { |
| Logger.get(context).logImpression(DialerImpression.Type.EMERGENCY_CANT_GET_LOCATION); |
| } |
| } |
| } |
| |
| @Override |
| public void onInCallScreenUnready() { |
| LogUtil.i("CallCardPresenter.onInCallScreenUnready", null); |
| Assert.checkState(isInCallScreenReady); |
| |
| // stop getting call state changes |
| InCallPresenter.getInstance().removeListener(this); |
| InCallPresenter.getInstance().removeIncomingCallListener(this); |
| InCallPresenter.getInstance().removeDetailsListener(this); |
| InCallPresenter.getInstance().removeInCallEventListener(this); |
| if (primary != null) { |
| primary.removeListener(this); |
| } |
| |
| callLocation.close(); |
| |
| primary = null; |
| primaryContactInfo = null; |
| secondaryContactInfo = null; |
| isInCallScreenReady = false; |
| } |
| |
| @Override |
| public void onIncomingCall(InCallState oldState, InCallState newState, DialerCall call) { |
| // same logic should happen as with onStateChange() |
| onStateChange(oldState, newState, CallList.getInstance()); |
| } |
| |
| @Override |
| public void onStateChange(InCallState oldState, InCallState newState, CallList callList) { |
| Trace.beginSection("CallCardPresenter.onStateChange"); |
| LogUtil.v("CallCardPresenter.onStateChange", "oldState: %s, newState: %s", oldState, newState); |
| if (inCallScreen == null) { |
| Trace.endSection(); |
| return; |
| } |
| |
| DialerCall primary = null; |
| DialerCall secondary = null; |
| |
| if (newState == InCallState.INCOMING) { |
| primary = callList.getIncomingCall(); |
| } else if (newState == InCallState.PENDING_OUTGOING || newState == InCallState.OUTGOING) { |
| primary = callList.getOutgoingCall(); |
| if (primary == null) { |
| primary = callList.getPendingOutgoingCall(); |
| } |
| |
| // getCallToDisplay doesn't go through outgoing or incoming calls. It will return the |
| // highest priority call to display as the secondary call. |
| secondary = InCallPresenter.getCallToDisplay(callList, null, true); |
| } else if (newState == InCallState.INCALL) { |
| primary = InCallPresenter.getCallToDisplay(callList, null, false); |
| secondary = InCallPresenter.getCallToDisplay(callList, primary, true); |
| } |
| |
| LogUtil.v("CallCardPresenter.onStateChange", "primary call: " + primary); |
| LogUtil.v("CallCardPresenter.onStateChange", "secondary call: " + secondary); |
| String primaryNumber = null; |
| String secondaryNumber = null; |
| if (primary != null) { |
| primaryNumber = primary.getNumber(); |
| } |
| if (secondary != null) { |
| secondaryNumber = secondary.getNumber(); |
| } |
| |
| final boolean primaryChanged = |
| !(DialerCall.areSame(this.primary, primary) |
| && TextUtils.equals(this.primaryNumber, primaryNumber)); |
| final boolean secondaryChanged = |
| !(DialerCall.areSame(this.secondary, secondary) |
| && TextUtils.equals(this.secondaryNumber, secondaryNumber)); |
| |
| this.secondary = secondary; |
| this.secondaryNumber = secondaryNumber; |
| DialerCall previousPrimary = this.primary; |
| this.primary = primary; |
| this.primaryNumber = primaryNumber; |
| |
| if (this.primary != null) { |
| inCallScreen.updateInCallScreenColors(); |
| } |
| |
| if (primaryChanged && shouldShowNoteSentToast(primary)) { |
| inCallScreen.showNoteSentToast(); |
| } |
| |
| // Refresh primary call information if either: |
| // 1. Primary call changed. |
| // 2. The call's ability to manage conference has changed. |
| if (shouldRefreshPrimaryInfo(primaryChanged)) { |
| // primary call has changed |
| if (previousPrimary != null) { |
| previousPrimary.removeListener(this); |
| } |
| this.primary.addListener(this); |
| |
| primaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(context, this.primary); |
| updatePrimaryDisplayInfo(); |
| maybeStartSearch(this.primary, true); |
| } |
| |
| if (previousPrimary != null && this.primary == null) { |
| previousPrimary.removeListener(this); |
| } |
| |
| if (secondaryChanged) { |
| if (this.secondary == null) { |
| // Secondary call may have ended. Update the ui. |
| secondaryContactInfo = null; |
| updateSecondaryDisplayInfo(); |
| } else { |
| // secondary call has changed |
| secondaryContactInfo = ContactInfoCache.buildCacheEntryFromCall(context, this.secondary); |
| updateSecondaryDisplayInfo(); |
| maybeStartSearch(this.secondary, false); |
| } |
| } |
| |
| // Set the call state |
| int callState = DialerCallState.IDLE; |
| if (this.primary != null) { |
| callState = this.primary.getState(); |
| updatePrimaryCallState(); |
| } else { |
| getUi().setCallState(PrimaryCallState.empty()); |
| } |
| |
| maybeShowManageConferenceCallButton(); |
| |
| // Hide the end call button instantly if we're receiving an incoming call. |
| getUi() |
| .setEndCallButtonEnabled( |
| shouldShowEndCallButton(this.primary, callState), |
| callState != DialerCallState.INCOMING /* animate */); |
| |
| maybeSendAccessibilityEvent(oldState, newState, primaryChanged); |
| Trace.endSection(); |
| } |
| |
| @Override |
| public void onDetailsChanged(DialerCall call, Details details) { |
| updatePrimaryCallState(); |
| |
| if (call.can(Details.CAPABILITY_MANAGE_CONFERENCE) |
| != details.can(Details.CAPABILITY_MANAGE_CONFERENCE)) { |
| maybeShowManageConferenceCallButton(); |
| } |
| } |
| |
| @Override |
| public void onDialerCallDisconnect() {} |
| |
| @Override |
| public void onDialerCallUpdate() { |
| // No-op; specific call updates handled elsewhere. |
| } |
| |
| @Override |
| public void onWiFiToLteHandover() {} |
| |
| @Override |
| public void onHandoverToWifiFailure() {} |
| |
| @Override |
| public void onInternationalCallOnWifi() {} |
| |
| @Override |
| public void onEnrichedCallSessionUpdate() { |
| LogUtil.enterBlock("CallCardPresenter.onEnrichedCallSessionUpdate"); |
| updatePrimaryDisplayInfo(); |
| } |
| |
| /** Handles a change to the child number by refreshing the primary call info. */ |
| @Override |
| public void onDialerCallChildNumberChange() { |
| LogUtil.v("CallCardPresenter.onDialerCallChildNumberChange", ""); |
| |
| if (primary == null) { |
| return; |
| } |
| updatePrimaryDisplayInfo(); |
| } |
| |
| /** Handles a change to the last forwarding number by refreshing the primary call info. */ |
| @Override |
| public void onDialerCallLastForwardedNumberChange() { |
| LogUtil.v("CallCardPresenter.onDialerCallLastForwardedNumberChange", ""); |
| |
| if (primary == null) { |
| return; |
| } |
| updatePrimaryDisplayInfo(); |
| updatePrimaryCallState(); |
| } |
| |
| @Override |
| public void onDialerCallUpgradeToVideo() {} |
| |
| /** Handles a change to the session modification state for a call. */ |
| @Override |
| public void onDialerCallSessionModificationStateChange() { |
| LogUtil.enterBlock("CallCardPresenter.onDialerCallSessionModificationStateChange"); |
| |
| if (primary == null) { |
| return; |
| } |
| getUi() |
| .setEndCallButtonEnabled( |
| primary.getVideoTech().getSessionModificationState() |
| != SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST, |
| true /* shouldAnimate */); |
| updatePrimaryCallState(); |
| } |
| |
| private boolean shouldRefreshPrimaryInfo(boolean primaryChanged) { |
| if (primary == null) { |
| return false; |
| } |
| return primaryChanged |
| || inCallScreen.isManageConferenceVisible() != shouldShowManageConference(); |
| } |
| |
| private void updatePrimaryCallState() { |
| if (getUi() != null && primary != null) { |
| boolean isWorkCall = |
| primary.hasProperty(PROPERTY_ENTERPRISE_CALL) |
| || (primaryContactInfo != null |
| && primaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK); |
| boolean isHdAudioCall = |
| isPrimaryCallActive() && primary.hasProperty(Details.PROPERTY_HIGH_DEF_AUDIO); |
| boolean isAttemptingHdAudioCall = |
| !isHdAudioCall |
| && !primary.hasProperty(DialerCall.PROPERTY_CODEC_KNOWN) |
| && MotorolaUtils.shouldBlinkHdIconWhenConnectingCall(context); |
| |
| boolean isBusiness = primaryContactInfo != null && primaryContactInfo.isBusiness; |
| |
| // Check for video state change and update the visibility of the contact photo. The contact |
| // photo is hidden when the incoming video surface is shown. |
| // The contact photo visibility can also change in setPrimary(). |
| boolean shouldShowContactPhoto = |
| !VideoCallPresenter.showIncomingVideo(primary.getVideoState(), primary.getState()); |
| getUi() |
| .setCallState( |
| PrimaryCallState.builder() |
| .setState(primary.getState()) |
| .setIsVideoCall(primary.isVideoCall()) |
| .setSessionModificationState(primary.getVideoTech().getSessionModificationState()) |
| .setDisconnectCause(primary.getDisconnectCause()) |
| .setConnectionLabel(getConnectionLabel()) |
| .setPrimaryColor( |
| InCallPresenter.getInstance().getThemeColorManager().getPrimaryColor()) |
| .setSimSuggestionReason(getSimSuggestionReason()) |
| .setConnectionIcon(getCallStateIcon()) |
| .setGatewayNumber(getGatewayNumber()) |
| .setCallSubject(shouldShowCallSubject(primary) ? primary.getCallSubject() : null) |
| .setCallbackNumber( |
| PhoneNumberHelper.formatNumber( |
| context, primary.getCallbackNumber(), primary.getSimCountryIso())) |
| .setIsWifi(primary.hasProperty(Details.PROPERTY_WIFI)) |
| .setIsConference( |
| primary.isConferenceCall() |
| && !primary.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE)) |
| .setIsWorkCall(isWorkCall) |
| .setIsHdAttempting(isAttemptingHdAudioCall) |
| .setIsHdAudioCall(isHdAudioCall) |
| .setIsForwardedNumber( |
| !TextUtils.isEmpty(primary.getLastForwardedNumber()) |
| || primary.isCallForwarded()) |
| .setShouldShowContactPhoto(shouldShowContactPhoto) |
| .setConnectTimeMillis(primary.getConnectTimeMillis()) |
| .setIsVoiceMailNumber(primary.isVoiceMailNumber()) |
| .setIsRemotelyHeld(primary.isRemotelyHeld()) |
| .setIsBusinessNumber(isBusiness) |
| .setSupportsCallOnHold(supports2ndCallOnHold()) |
| .setSwapToSecondaryButtonState(getSwapToSecondaryButtonState()) |
| .setIsAssistedDialed(primary.isAssistedDialed()) |
| .setCustomLabel(null) |
| .setAssistedDialingExtras(primary.getAssistedDialingExtras()) |
| .build()); |
| |
| InCallActivity activity = |
| (InCallActivity) (inCallScreen.getInCallScreenFragment().getActivity()); |
| if (activity != null) { |
| activity.onPrimaryCallStateChanged(); |
| } |
| } |
| } |
| |
| private @ButtonState int getSwapToSecondaryButtonState() { |
| if (secondary == null) { |
| return ButtonState.NOT_SUPPORT; |
| } |
| if (primary.getState() == DialerCallState.ACTIVE) { |
| return ButtonState.ENABLED; |
| } |
| return ButtonState.DISABLED; |
| } |
| |
| /** Only show the conference call button if we can manage the conference. */ |
| private void maybeShowManageConferenceCallButton() { |
| getUi().showManageConferenceCallButton(shouldShowManageConference()); |
| } |
| |
| /** |
| * Determines if the manage conference button should be visible, based on the current primary |
| * call. |
| * |
| * @return {@code True} if the manage conference button should be visible. |
| */ |
| private boolean shouldShowManageConference() { |
| if (primary == null) { |
| return false; |
| } |
| |
| return primary.can(android.telecom.Call.Details.CAPABILITY_MANAGE_CONFERENCE) && !isFullscreen; |
| } |
| |
| private boolean supports2ndCallOnHold() { |
| DialerCall firstCall = CallList.getInstance().getActiveOrBackgroundCall(); |
| DialerCall incomingCall = CallList.getInstance().getIncomingCall(); |
| if (firstCall != null && incomingCall != null && firstCall != incomingCall) { |
| return incomingCall.can(Details.CAPABILITY_HOLD); |
| } |
| return true; |
| } |
| |
| @Override |
| public void onCallStateButtonClicked() { |
| Intent broadcastIntent = Bindings.get(context).getCallStateButtonBroadcastIntent(context); |
| if (broadcastIntent != null) { |
| LogUtil.v( |
| "CallCardPresenter.onCallStateButtonClicked", |
| "sending call state button broadcast: " + broadcastIntent); |
| context.sendBroadcast(broadcastIntent, Manifest.permission.READ_PHONE_STATE); |
| } |
| } |
| |
| @Override |
| public void onManageConferenceClicked() { |
| InCallActivity activity = |
| (InCallActivity) (inCallScreen.getInCallScreenFragment().getActivity()); |
| activity.showConferenceFragment(true); |
| } |
| |
| @Override |
| public void onShrinkAnimationComplete() { |
| InCallPresenter.getInstance().onShrinkAnimationComplete(); |
| } |
| |
| private void maybeStartSearch(DialerCall call, boolean isPrimary) { |
| // no need to start search for conference calls which show generic info. |
| if (call != null && !call.isConferenceCall()) { |
| startContactInfoSearch(call, isPrimary, call.getState() == DialerCallState.INCOMING); |
| } |
| } |
| |
| /** Starts a query for more contact data for the save primary and secondary calls. */ |
| private void startContactInfoSearch( |
| final DialerCall call, final boolean isPrimary, boolean isIncoming) { |
| final ContactInfoCache cache = ContactInfoCache.getInstance(context); |
| |
| cache.findInfo(call, isIncoming, new ContactLookupCallback(this, isPrimary)); |
| } |
| |
| private void onContactInfoComplete(String callId, ContactCacheEntry entry, boolean isPrimary) { |
| final boolean entryMatchesExistingCall = |
| (isPrimary && primary != null && TextUtils.equals(callId, primary.getId())) |
| || (!isPrimary && secondary != null && TextUtils.equals(callId, secondary.getId())); |
| if (entryMatchesExistingCall) { |
| updateContactEntry(entry, isPrimary); |
| } else { |
| LogUtil.e( |
| "CallCardPresenter.onContactInfoComplete", |
| "dropping stale contact lookup info for " + callId); |
| } |
| |
| final DialerCall call = CallList.getInstance().getCallById(callId); |
| if (call != null) { |
| call.getLogState().contactLookupResult = entry.contactLookupResult; |
| } |
| if (entry.lookupUri != null) { |
| CallerInfoUtils.sendViewNotification(context, entry.lookupUri); |
| } |
| } |
| |
| private void onImageLoadComplete(String callId, ContactCacheEntry entry) { |
| if (getUi() == null) { |
| return; |
| } |
| |
| if (entry.photo != null) { |
| if (primary != null && callId.equals(primary.getId())) { |
| updateContactEntry(entry, true /* isPrimary */); |
| } else if (secondary != null && callId.equals(secondary.getId())) { |
| updateContactEntry(entry, false /* isPrimary */); |
| } |
| } |
| } |
| |
| private void updateContactEntry(ContactCacheEntry entry, boolean isPrimary) { |
| if (isPrimary) { |
| primaryContactInfo = entry; |
| updatePrimaryDisplayInfo(); |
| } else { |
| secondaryContactInfo = entry; |
| updateSecondaryDisplayInfo(); |
| } |
| } |
| |
| private void updatePrimaryDisplayInfo() { |
| if (inCallScreen == null) { |
| // TODO: May also occur if search result comes back after ui is destroyed. Look into |
| // removing that case completely. |
| LogUtil.v( |
| "CallCardPresenter.updatePrimaryDisplayInfo", |
| "updatePrimaryDisplayInfo called but ui is null!"); |
| return; |
| } |
| |
| if (primary == null) { |
| // Clear the primary display info. |
| inCallScreen.setPrimary(PrimaryInfo.empty()); |
| return; |
| } |
| |
| // Hide the contact photo if we are in a video call and the incoming video surface is |
| // showing. |
| boolean showContactPhoto = |
| !VideoCallPresenter.showIncomingVideo(primary.getVideoState(), primary.getState()); |
| |
| // DialerCall placed through a work phone account. |
| boolean hasWorkCallProperty = primary.hasProperty(PROPERTY_ENTERPRISE_CALL); |
| |
| MultimediaData multimediaData = null; |
| if (primary.getEnrichedCallSession() != null) { |
| multimediaData = primary.getEnrichedCallSession().getMultimediaData(); |
| } |
| |
| if (primary.isConferenceCall()) { |
| LogUtil.v( |
| "CallCardPresenter.updatePrimaryDisplayInfo", |
| "update primary display info for conference call."); |
| |
| inCallScreen.setPrimary( |
| PrimaryInfo.builder() |
| .setName( |
| CallerInfoUtils.getConferenceString( |
| context, primary.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE))) |
| .setNameIsNumber(false) |
| .setPhotoType(ContactPhotoType.DEFAULT_PLACEHOLDER) |
| .setIsSipCall(false) |
| .setIsContactPhotoShown(showContactPhoto) |
| .setIsWorkCall(hasWorkCallProperty) |
| .setIsSpam(false) |
| .setIsLocalContact(false) |
| .setAnsweringDisconnectsOngoingCall(false) |
| .setShouldShowLocation(shouldShowLocation()) |
| .setShowInCallButtonGrid(true) |
| .setNumberPresentation(primary.getNumberPresentation()) |
| .build()); |
| } else if (primaryContactInfo != null) { |
| LogUtil.v( |
| "CallCardPresenter.updatePrimaryDisplayInfo", |
| "update primary display info for " + primaryContactInfo); |
| |
| String name = getNameForCall(primaryContactInfo); |
| String number; |
| |
| boolean isChildNumberShown = !TextUtils.isEmpty(primary.getChildNumber()); |
| boolean isForwardedNumberShown = !TextUtils.isEmpty(primary.getLastForwardedNumber()); |
| boolean isCallSubjectShown = shouldShowCallSubject(primary); |
| |
| if (isCallSubjectShown) { |
| number = null; |
| } else if (isChildNumberShown) { |
| number = context.getString(R.string.child_number, primary.getChildNumber()); |
| } else if (isForwardedNumberShown) { |
| // Use last forwarded number instead of second line, if present. |
| number = primary.getLastForwardedNumber(); |
| } else { |
| number = primaryContactInfo.number; |
| } |
| |
| boolean nameIsNumber = name != null && name.equals(primaryContactInfo.number); |
| |
| // DialerCall with caller that is a work contact. |
| boolean isWorkContact = (primaryContactInfo.userType == ContactsUtils.USER_TYPE_WORK); |
| inCallScreen.setPrimary( |
| PrimaryInfo.builder() |
| .setNumber(number) |
| .setName(primary.updateNameIfRestricted(name)) |
| .setNameIsNumber(nameIsNumber) |
| .setLocation( |
| shouldShowLocationAsLabel(nameIsNumber, primaryContactInfo.shouldShowLocation) |
| ? primaryContactInfo.location |
| : null) |
| .setLabel(isChildNumberShown || isCallSubjectShown ? null : primaryContactInfo.label) |
| .setPhoto(primaryContactInfo.photo) |
| .setPhotoUri(primaryContactInfo.displayPhotoUri) |
| .setPhotoType(primaryContactInfo.photoType) |
| .setIsSipCall(primaryContactInfo.isSipCall) |
| .setIsContactPhotoShown(showContactPhoto) |
| .setIsWorkCall(hasWorkCallProperty || isWorkContact) |
| .setIsSpam(primary.isSpam()) |
| .setIsLocalContact(primaryContactInfo.isLocalContact()) |
| .setAnsweringDisconnectsOngoingCall(primary.answeringDisconnectsForegroundVideoCall()) |
| .setShouldShowLocation(shouldShowLocation()) |
| .setContactInfoLookupKey(primaryContactInfo.lookupKey) |
| .setMultimediaData(multimediaData) |
| .setShowInCallButtonGrid(true) |
| .setNumberPresentation(primary.getNumberPresentation()) |
| .build()); |
| } else { |
| // Clear the primary display info. |
| inCallScreen.setPrimary(PrimaryInfo.empty()); |
| } |
| |
| if (isInCallScreenReady) { |
| inCallScreen.showLocationUi(getLocationFragment()); |
| } else { |
| LogUtil.i("CallCardPresenter.updatePrimaryDisplayInfo", "UI not ready, not showing location"); |
| } |
| } |
| |
| private static boolean shouldShowLocationAsLabel( |
| boolean nameIsNumber, boolean shouldShowLocation) { |
| if (nameIsNumber) { |
| return true; |
| } |
| if (shouldShowLocation) { |
| return true; |
| } |
| return false; |
| } |
| |
| private Fragment getLocationFragment() { |
| if (!shouldShowLocation()) { |
| return null; |
| } |
| LogUtil.i("CallCardPresenter.getLocationFragment", "returning location fragment"); |
| return callLocation.getLocationFragment(context); |
| } |
| |
| private boolean shouldShowLocation() { |
| if (!ConfigProviderComponent.get(context) |
| .getConfigProvider() |
| .getBoolean(CONFIG_ENABLE_EMERGENCY_LOCATION, CONFIG_ENABLE_EMERGENCY_LOCATION_DEFAULT)) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "disabled by config."); |
| return false; |
| } |
| if (!isPotentialEmergencyCall()) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "shouldn't show location"); |
| return false; |
| } |
| if (!hasLocationPermission()) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "no location permission."); |
| return false; |
| } |
| if (isBatteryTooLowForEmergencyLocation()) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "low battery."); |
| return false; |
| } |
| if (inCallScreen.getInCallScreenFragment().getActivity().isInMultiWindowMode()) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "in multi-window mode"); |
| return false; |
| } |
| if (primary.isVideoCall()) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "emergency video calls not supported"); |
| return false; |
| } |
| if (!callLocation.canGetLocation(context)) { |
| LogUtil.i("CallCardPresenter.getLocationFragment", "can't get current location"); |
| return false; |
| } |
| return true; |
| } |
| |
| private boolean isPotentialEmergencyCall() { |
| if (isOutgoingEmergencyCall(primary)) { |
| LogUtil.i("CallCardPresenter.shouldShowLocation", "new emergency call"); |
| return true; |
| } else if (isIncomingEmergencyCall(primary)) { |
| LogUtil.i("CallCardPresenter.shouldShowLocation", "potential emergency callback"); |
| return true; |
| } else if (isIncomingEmergencyCall(secondary)) { |
| LogUtil.i("CallCardPresenter.shouldShowLocation", "has potential emergency callback"); |
| return true; |
| } |
| return false; |
| } |
| |
| private static boolean isOutgoingEmergencyCall(@Nullable DialerCall call) { |
| return call != null && !call.isIncoming() && call.isEmergencyCall(); |
| } |
| |
| private static boolean isIncomingEmergencyCall(@Nullable DialerCall call) { |
| return call != null && call.isIncoming() && call.isPotentialEmergencyCallback(); |
| } |
| |
| private boolean hasLocationPermission() { |
| return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) |
| == PackageManager.PERMISSION_GRANTED; |
| } |
| |
| private boolean isBatteryTooLowForEmergencyLocation() { |
| Intent batteryStatus = |
| context.registerReceiver(null, new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); |
| int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1); |
| if (status == BatteryManager.BATTERY_STATUS_CHARGING |
| || status == BatteryManager.BATTERY_STATUS_FULL) { |
| // Plugged in or full battery |
| return false; |
| } |
| int level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1); |
| int scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1); |
| float batteryPercent = (100f * level) / scale; |
| long threshold = |
| ConfigProviderComponent.get(context) |
| .getConfigProvider() |
| .getLong( |
| CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION, |
| CONFIG_MIN_BATTERY_PERCENT_FOR_EMERGENCY_LOCATION_DEFAULT); |
| LogUtil.i( |
| "CallCardPresenter.isBatteryTooLowForEmergencyLocation", |
| "percent charged: " + batteryPercent + ", min required charge: " + threshold); |
| return batteryPercent < threshold; |
| } |
| |
| private void updateSecondaryDisplayInfo() { |
| if (inCallScreen == null) { |
| return; |
| } |
| |
| if (secondary == null) { |
| // Clear the secondary display info. |
| inCallScreen.setSecondary(SecondaryInfo.builder().setIsFullscreen(isFullscreen).build()); |
| return; |
| } |
| |
| if (secondary.isMergeInProcess()) { |
| LogUtil.i( |
| "CallCardPresenter.updateSecondaryDisplayInfo", |
| "secondary call is merge in process, clearing info"); |
| inCallScreen.setSecondary(SecondaryInfo.builder().setIsFullscreen(isFullscreen).build()); |
| return; |
| } |
| |
| if (secondary.isConferenceCall()) { |
| inCallScreen.setSecondary( |
| SecondaryInfo.builder() |
| .setShouldShow(true) |
| .setName( |
| CallerInfoUtils.getConferenceString( |
| context, secondary.hasProperty(Details.PROPERTY_GENERIC_CONFERENCE))) |
| .setProviderLabel(secondary.getCallProviderLabel()) |
| .setIsConference(true) |
| .setIsVideoCall(secondary.isVideoCall()) |
| .setIsFullscreen(isFullscreen) |
| .build()); |
| } else if (secondaryContactInfo != null) { |
| LogUtil.v("CallCardPresenter.updateSecondaryDisplayInfo", "" + secondaryContactInfo); |
| String name = getNameForCall(secondaryContactInfo); |
| boolean nameIsNumber = name != null && name.equals(secondaryContactInfo.number); |
| inCallScreen.setSecondary( |
| SecondaryInfo.builder() |
| .setShouldShow(true) |
| .setName(secondary.updateNameIfRestricted(name)) |
| .setNameIsNumber(nameIsNumber) |
| .setLabel(secondaryContactInfo.label) |
| .setProviderLabel(secondary.getCallProviderLabel()) |
| .setIsVideoCall(secondary.isVideoCall()) |
| .setIsFullscreen(isFullscreen) |
| .build()); |
| } else { |
| // Clear the secondary display info. |
| inCallScreen.setSecondary(SecondaryInfo.builder().setIsFullscreen(isFullscreen).build()); |
| } |
| } |
| |
| /** Returns the gateway number for any existing outgoing call. */ |
| private String getGatewayNumber() { |
| if (hasOutgoingGatewayCall()) { |
| return DialerCall.getNumberFromHandle(primary.getGatewayInfo().getGatewayAddress()); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the label (line of text above the number/name) for any given call. For example, |
| * "calling via [Account/Google Voice]" for outgoing calls. |
| */ |
| private String getConnectionLabel() { |
| if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE) |
| != PackageManager.PERMISSION_GRANTED) { |
| return null; |
| } |
| StatusHints statusHints = primary.getStatusHints(); |
| if (statusHints != null && !TextUtils.isEmpty(statusHints.getLabel())) { |
| return statusHints.getLabel().toString(); |
| } |
| |
| if (hasOutgoingGatewayCall() && getUi() != null) { |
| // Return the label for the gateway app on outgoing calls. |
| final PackageManager pm = context.getPackageManager(); |
| try { |
| ApplicationInfo info = |
| pm.getApplicationInfo(primary.getGatewayInfo().getGatewayProviderPackageName(), 0); |
| return pm.getApplicationLabel(info).toString(); |
| } catch (PackageManager.NameNotFoundException e) { |
| LogUtil.e("CallCardPresenter.getConnectionLabel", "gateway Application Not Found.", e); |
| return null; |
| } |
| } |
| return primary.getCallProviderLabel(); |
| } |
| |
| @Nullable |
| private SuggestionProvider.Reason getSimSuggestionReason() { |
| String value = |
| primary.getIntentExtras().getString(SuggestionProvider.EXTRA_SIM_SUGGESTION_REASON); |
| if (value == null) { |
| return null; |
| } |
| try { |
| return SuggestionProvider.Reason.valueOf(value); |
| } catch (IllegalArgumentException e) { |
| LogUtil.e("CallCardPresenter.getConnectionLabel", "unknown reason " + value); |
| return null; |
| } |
| } |
| |
| private Drawable getCallStateIcon() { |
| // Return connection icon if one exists. |
| StatusHints statusHints = primary.getStatusHints(); |
| if (statusHints != null && statusHints.getIcon() != null) { |
| Drawable icon = statusHints.getIcon().loadDrawable(context); |
| if (icon != null) { |
| return icon; |
| } |
| } |
| |
| return null; |
| } |
| |
| private boolean hasOutgoingGatewayCall() { |
| // We only display the gateway information while STATE_DIALING so return false for any other |
| // call state. |
| // TODO: mPrimary can be null because this is called from updatePrimaryDisplayInfo which |
| // is also called after a contact search completes (call is not present yet). Split the |
| // UI update so it can receive independent updates. |
| if (primary == null) { |
| return false; |
| } |
| return DialerCallState.isDialing(primary.getState()) |
| && primary.getGatewayInfo() != null |
| && !primary.getGatewayInfo().isEmpty(); |
| } |
| |
| /** Gets the name to display for the call. */ |
| private String getNameForCall(ContactCacheEntry contactInfo) { |
| String preferredName = |
| ContactsComponent.get(context) |
| .contactDisplayPreferences() |
| .getDisplayName(contactInfo.namePrimary, contactInfo.nameAlternative); |
| if (TextUtils.isEmpty(preferredName)) { |
| return TextUtils.isEmpty(contactInfo.number) |
| ? null |
| : BidiFormatter.getInstance() |
| .unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR); |
| } |
| return preferredName; |
| } |
| |
| @Override |
| public void onSecondaryInfoClicked() { |
| if (secondary == null) { |
| LogUtil.e( |
| "CallCardPresenter.onSecondaryInfoClicked", |
| "secondary info clicked but no secondary call."); |
| return; |
| } |
| |
| Logger.get(context) |
| .logCallImpression( |
| DialerImpression.Type.IN_CALL_SWAP_SECONDARY_BUTTON_PRESSED, |
| primary.getUniqueCallId(), |
| primary.getTimeAddedMs()); |
| LogUtil.i( |
| "CallCardPresenter.onSecondaryInfoClicked", "swapping call to foreground: " + secondary); |
| secondary.unhold(); |
| } |
| |
| @Override |
| public void onEndCallClicked() { |
| LogUtil.i("CallCardPresenter.onEndCallClicked", "disconnecting call: " + primary); |
| if (primary != null) { |
| primary.disconnect(); |
| } |
| PostCall.onDisconnectPressed(context); |
| } |
| |
| /** |
| * Handles a change to the fullscreen mode of the in-call UI. |
| * |
| * @param isFullscreenMode {@code True} if the in-call UI is entering full screen mode. |
| */ |
| @Override |
| public void onFullscreenModeChanged(boolean isFullscreenMode) { |
| isFullscreen = isFullscreenMode; |
| if (inCallScreen == null) { |
| return; |
| } |
| maybeShowManageConferenceCallButton(); |
| } |
| |
| private boolean isPrimaryCallActive() { |
| return primary != null && primary.getState() == DialerCallState.ACTIVE; |
| } |
| |
| private boolean shouldShowEndCallButton(DialerCall primary, int callState) { |
| if (primary == null) { |
| return false; |
| } |
| if ((!DialerCallState.isConnectingOrConnected(callState) |
| && callState != DialerCallState.DISCONNECTING |
| && callState != DialerCallState.DISCONNECTED) |
| || callState == DialerCallState.INCOMING) { |
| return false; |
| } |
| if (this.primary.getVideoTech().getSessionModificationState() |
| == SessionModificationState.RECEIVED_UPGRADE_TO_VIDEO_REQUEST) { |
| return false; |
| } |
| return true; |
| } |
| |
| @Override |
| public void onInCallScreenResumed() { |
| updatePrimaryDisplayInfo(); |
| |
| if (shouldSendAccessibilityEvent) { |
| handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS); |
| } |
| } |
| |
| @Override |
| public void onInCallScreenPaused() {} |
| |
| static boolean sendAccessibilityEvent(Context context, InCallScreen inCallScreen) { |
| AccessibilityManager am = |
| (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE); |
| if (!am.isEnabled()) { |
| LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "accessibility is off"); |
| return false; |
| } |
| if (inCallScreen == null) { |
| LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "incallscreen is null"); |
| return false; |
| } |
| Fragment fragment = inCallScreen.getInCallScreenFragment(); |
| if (fragment == null || fragment.getView() == null || fragment.getView().getParent() == null) { |
| LogUtil.w("CallCardPresenter.sendAccessibilityEvent", "fragment/view/parent is null"); |
| return false; |
| } |
| |
| DisplayManager displayManager = |
| (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE); |
| Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY); |
| boolean screenIsOn = display.getState() == Display.STATE_ON; |
| LogUtil.d("CallCardPresenter.sendAccessibilityEvent", "screen is on: %b", screenIsOn); |
| if (!screenIsOn) { |
| return false; |
| } |
| |
| AccessibilityEvent event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_ANNOUNCEMENT); |
| inCallScreen.dispatchPopulateAccessibilityEvent(event); |
| View view = inCallScreen.getInCallScreenFragment().getView(); |
| view.getParent().requestSendAccessibilityEvent(view, event); |
| return true; |
| } |
| |
| private void maybeSendAccessibilityEvent( |
| InCallState oldState, final InCallState newState, boolean primaryChanged) { |
| shouldSendAccessibilityEvent = false; |
| if (context == null) { |
| return; |
| } |
| final AccessibilityManager am = |
| (AccessibilityManager) context.getSystemService(Context.ACCESSIBILITY_SERVICE); |
| if (!am.isEnabled()) { |
| return; |
| } |
| // Announce the current call if it's new incoming/outgoing call or primary call is changed |
| // due to switching calls between two ongoing calls (one is on hold). |
| if ((oldState != InCallState.OUTGOING && newState == InCallState.OUTGOING) |
| || (oldState != InCallState.INCOMING && newState == InCallState.INCOMING) |
| || primaryChanged) { |
| LogUtil.i( |
| "CallCardPresenter.maybeSendAccessibilityEvent", "schedule accessibility announcement"); |
| shouldSendAccessibilityEvent = true; |
| handler.postDelayed(sendAccessibilityEventRunnable, ACCESSIBILITY_ANNOUNCEMENT_DELAY_MILLIS); |
| } |
| } |
| |
| /** |
| * Determines whether the call subject should be visible on the UI. For the call subject to be |
| * visible, the call has to be in an incoming or waiting state, and the subject must not be empty. |
| * |
| * @param call The call. |
| * @return {@code true} if the subject should be shown, {@code false} otherwise. |
| */ |
| private boolean shouldShowCallSubject(DialerCall call) { |
| if (call == null) { |
| return false; |
| } |
| |
| boolean isIncomingOrWaiting = |
| primary.getState() == DialerCallState.INCOMING |
| || primary.getState() == DialerCallState.CALL_WAITING; |
| return isIncomingOrWaiting |
| && !TextUtils.isEmpty(call.getCallSubject()) |
| && call.getNumberPresentation() == TelecomManager.PRESENTATION_ALLOWED |
| && call.isCallSubjectSupported(); |
| } |
| |
| /** |
| * Determines whether the "note sent" toast should be shown. It should be shown for a new outgoing |
| * call with a subject. |
| * |
| * @param call The call |
| * @return {@code true} if the toast should be shown, {@code false} otherwise. |
| */ |
| private boolean shouldShowNoteSentToast(DialerCall call) { |
| return call != null |
| && hasCallSubject(call) |
| && (call.getState() == DialerCallState.DIALING |
| || call.getState() == DialerCallState.CONNECTING); |
| } |
| |
| private InCallScreen getUi() { |
| return inCallScreen; |
| } |
| |
| /** Callback for contact lookup. */ |
| public static class ContactLookupCallback implements ContactInfoCacheCallback { |
| |
| private final WeakReference<CallCardPresenter> callCardPresenter; |
| private final boolean isPrimary; |
| |
| public ContactLookupCallback(CallCardPresenter callCardPresenter, boolean isPrimary) { |
| this.callCardPresenter = new WeakReference<CallCardPresenter>(callCardPresenter); |
| this.isPrimary = isPrimary; |
| } |
| |
| @Override |
| public void onContactInfoComplete(String callId, ContactCacheEntry entry) { |
| CallCardPresenter presenter = callCardPresenter.get(); |
| if (presenter != null) { |
| presenter.onContactInfoComplete(callId, entry, isPrimary); |
| } |
| } |
| |
| @Override |
| public void onImageLoadComplete(String callId, ContactCacheEntry entry) { |
| CallCardPresenter presenter = callCardPresenter.get(); |
| if (presenter != null) { |
| presenter.onImageLoadComplete(callId, entry); |
| } |
| } |
| } |
| } |
