diff options
Diffstat (limited to 'src/com/android/phone/CallCard.java')
| -rw-r--r-- | src/com/android/phone/CallCard.java | 1787 |
1 files changed, 1787 insertions, 0 deletions
diff --git a/src/com/android/phone/CallCard.java b/src/com/android/phone/CallCard.java new file mode 100644 index 00000000..682113fd --- /dev/null +++ b/src/com/android/phone/CallCard.java @@ -0,0 +1,1787 @@ +/* + * Copyright (C) 2006 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.phone; + +import android.animation.LayoutTransition; +import android.content.ContentUris; +import android.content.Context; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.net.Uri; +import android.os.Handler; +import android.os.Message; +import android.provider.ContactsContract.Contacts; +import android.telephony.PhoneNumberUtils; +import android.text.TextUtils; +import android.text.format.DateUtils; +import android.util.AttributeSet; +import android.util.Log; +import android.view.Gravity; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewStub; +import android.view.accessibility.AccessibilityEvent; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; + +import com.android.internal.telephony.Call; +import com.android.internal.telephony.CallManager; +import com.android.internal.telephony.CallerInfo; +import com.android.internal.telephony.CallerInfoAsyncQuery; +import com.android.internal.telephony.Connection; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneConstants; + +import java.util.List; + + +/** + * "Call card" UI element: the in-call screen contains a tiled layout of call + * cards, each representing the state of a current "call" (ie. an active call, + * a call on hold, or an incoming call.) + */ +public class CallCard extends LinearLayout + implements CallTime.OnTickListener, CallerInfoAsyncQuery.OnQueryCompleteListener, + ContactsAsyncHelper.OnImageLoadCompleteListener { + private static final String LOG_TAG = "CallCard"; + private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2); + + private static final int TOKEN_UPDATE_PHOTO_FOR_CALL_STATE = 0; + private static final int TOKEN_DO_NOTHING = 1; + + /** + * Used with {@link ContactsAsyncHelper#startObtainPhotoAsync(int, Context, Uri, + * ContactsAsyncHelper.OnImageLoadCompleteListener, Object)} + */ + private static class AsyncLoadCookie { + public final ImageView imageView; + public final CallerInfo callerInfo; + public final Call call; + public AsyncLoadCookie(ImageView imageView, CallerInfo callerInfo, Call call) { + this.imageView = imageView; + this.callerInfo = callerInfo; + this.call = call; + } + } + + /** + * Reference to the InCallScreen activity that owns us. This may be + * null if we haven't been initialized yet *or* after the InCallScreen + * activity has been destroyed. + */ + private InCallScreen mInCallScreen; + + // Phone app instance + private PhoneGlobals mApplication; + + // Top-level subviews of the CallCard + /** Container for info about the current call(s) */ + private ViewGroup mCallInfoContainer; + /** Primary "call info" block (the foreground or ringing call) */ + private ViewGroup mPrimaryCallInfo; + /** "Call banner" for the primary call */ + private ViewGroup mPrimaryCallBanner; + /** Secondary "call info" block (the background "on hold" call) */ + private ViewStub mSecondaryCallInfo; + + /** + * Container for both provider info and call state. This will take care of showing/hiding + * animation for those views. + */ + private ViewGroup mSecondaryInfoContainer; + private ViewGroup mProviderInfo; + private TextView mProviderLabel; + private TextView mProviderAddress; + + // "Call state" widgets + private TextView mCallStateLabel; + private TextView mElapsedTime; + + // Text colors, used for various labels / titles + private int mTextColorCallTypeSip; + + // The main block of info about the "primary" or "active" call, + // including photo / name / phone number / etc. + private ImageView mPhoto; + private View mPhotoDimEffect; + + private TextView mName; + private TextView mPhoneNumber; + private TextView mLabel; + private TextView mCallTypeLabel; + // private TextView mSocialStatus; + + /** + * Uri being used to load contact photo for mPhoto. Will be null when nothing is being loaded, + * or a photo is already loaded. + */ + private Uri mLoadingPersonUri; + + // Info about the "secondary" call, which is the "call on hold" when + // two lines are in use. + private TextView mSecondaryCallName; + private ImageView mSecondaryCallPhoto; + private View mSecondaryCallPhotoDimEffect; + + // Onscreen hint for the incoming call RotarySelector widget. + private int mIncomingCallWidgetHintTextResId; + private int mIncomingCallWidgetHintColorResId; + + private CallTime mCallTime; + + // Track the state for the photo. + private ContactsAsyncHelper.ImageTracker mPhotoTracker; + + // Cached DisplayMetrics density. + private float mDensity; + + /** + * Sent when it takes too long (MESSAGE_DELAY msec) to load a contact photo for the given + * person, at which we just start showing the default avatar picture instead of the person's + * one. Note that we will *not* cancel the ongoing query and eventually replace the avatar + * with the person's photo, when it is available anyway. + */ + private static final int MESSAGE_SHOW_UNKNOWN_PHOTO = 101; + private static final int MESSAGE_DELAY = 500; // msec + private final Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case MESSAGE_SHOW_UNKNOWN_PHOTO: + showImage(mPhoto, R.drawable.picture_unknown); + break; + default: + Log.wtf(LOG_TAG, "mHandler: unexpected message: " + msg); + break; + } + } + }; + + public CallCard(Context context, AttributeSet attrs) { + super(context, attrs); + + if (DBG) log("CallCard constructor..."); + if (DBG) log("- this = " + this); + if (DBG) log("- context " + context + ", attrs " + attrs); + + mApplication = PhoneGlobals.getInstance(); + + mCallTime = new CallTime(this); + + // create a new object to track the state for the photo. + mPhotoTracker = new ContactsAsyncHelper.ImageTracker(); + + mDensity = getResources().getDisplayMetrics().density; + if (DBG) log("- Density: " + mDensity); + } + + /* package */ void setInCallScreenInstance(InCallScreen inCallScreen) { + mInCallScreen = inCallScreen; + } + + @Override + public void onTickForCallTimeElapsed(long timeElapsed) { + // While a call is in progress, update the elapsed time shown + // onscreen. + updateElapsedTimeWidget(timeElapsed); + } + + /* package */ void stopTimer() { + mCallTime.cancelTimer(); + } + + @Override + protected void onFinishInflate() { + super.onFinishInflate(); + + if (DBG) log("CallCard onFinishInflate(this = " + this + ")..."); + + mCallInfoContainer = (ViewGroup) findViewById(R.id.call_info_container); + mPrimaryCallInfo = (ViewGroup) findViewById(R.id.primary_call_info); + mPrimaryCallBanner = (ViewGroup) findViewById(R.id.primary_call_banner); + + mSecondaryInfoContainer = (ViewGroup) findViewById(R.id.secondary_info_container); + mProviderInfo = (ViewGroup) findViewById(R.id.providerInfo); + mProviderLabel = (TextView) findViewById(R.id.providerLabel); + mProviderAddress = (TextView) findViewById(R.id.providerAddress); + mCallStateLabel = (TextView) findViewById(R.id.callStateLabel); + mElapsedTime = (TextView) findViewById(R.id.elapsedTime); + + // Text colors + mTextColorCallTypeSip = getResources().getColor(R.color.incall_callTypeSip); + + // "Caller info" area, including photo / name / phone numbers / etc + mPhoto = (ImageView) findViewById(R.id.photo); + mPhotoDimEffect = findViewById(R.id.dim_effect_for_primary_photo); + + mName = (TextView) findViewById(R.id.name); + mPhoneNumber = (TextView) findViewById(R.id.phoneNumber); + mLabel = (TextView) findViewById(R.id.label); + mCallTypeLabel = (TextView) findViewById(R.id.callTypeLabel); + // mSocialStatus = (TextView) findViewById(R.id.socialStatus); + + // Secondary info area, for the background ("on hold") call + mSecondaryCallInfo = (ViewStub) findViewById(R.id.secondary_call_info); + } + + /** + * Updates the state of all UI elements on the CallCard, based on the + * current state of the phone. + */ + /* package */ void updateState(CallManager cm) { + if (DBG) log("updateState(" + cm + ")..."); + + // Update the onscreen UI based on the current state of the phone. + + PhoneConstants.State state = cm.getState(); // IDLE, RINGING, or OFFHOOK + Call ringingCall = cm.getFirstActiveRingingCall(); + Call fgCall = cm.getActiveFgCall(); + Call bgCall = cm.getFirstActiveBgCall(); + + // Update the overall layout of the onscreen elements, if in PORTRAIT. + // Portrait uses a programatically altered layout, whereas landscape uses layout xml's. + // Landscape view has the views side by side, so no shifting of the picture is needed + if (!PhoneUtils.isLandscape(this.getContext())) { + updateCallInfoLayout(state); + } + + // If the FG call is dialing/alerting, we should display for that call + // and ignore the ringing call. This case happens when the telephony + // layer rejects the ringing call while the FG call is dialing/alerting, + // but the incoming call *does* briefly exist in the DISCONNECTING or + // DISCONNECTED state. + if ((ringingCall.getState() != Call.State.IDLE) + && !fgCall.getState().isDialing()) { + // A phone call is ringing, call waiting *or* being rejected + // (ie. another call may also be active as well.) + updateRingingCall(cm); + } else if ((fgCall.getState() != Call.State.IDLE) + || (bgCall.getState() != Call.State.IDLE)) { + // We are here because either: + // (1) the phone is off hook. At least one call exists that is + // dialing, active, or holding, and no calls are ringing or waiting, + // or: + // (2) the phone is IDLE but a call just ended and it's still in + // the DISCONNECTING or DISCONNECTED state. In this case, we want + // the main CallCard to display "Hanging up" or "Call ended". + // The normal "foreground call" code path handles both cases. + updateForegroundCall(cm); + } else { + // We don't have any DISCONNECTED calls, which means that the phone + // is *truly* idle. + if (mApplication.inCallUiState.showAlreadyDisconnectedState) { + // showAlreadyDisconnectedState implies the phone call is disconnected + // and we want to show the disconnected phone call for a moment. + // + // This happens when a phone call ends while the screen is off, + // which means the user had no chance to see the last status of + // the call. We'll turn off showAlreadyDisconnectedState flag + // and bail out of the in-call screen soon. + updateAlreadyDisconnected(cm); + } else { + // It's very rare to be on the InCallScreen at all in this + // state, but it can happen in some cases: + // - A stray onPhoneStateChanged() event came in to the + // InCallScreen *after* it was dismissed. + // - We're allowed to be on the InCallScreen because + // an MMI or USSD is running, but there's no actual "call" + // to display. + // - We're displaying an error dialog to the user + // (explaining why the call failed), so we need to stay on + // the InCallScreen so that the dialog will be visible. + // + // In these cases, put the callcard into a sane but "blank" state: + updateNoCall(cm); + } + } + } + + /** + * Updates the overall size and positioning of mCallInfoContainer and + * the "Call info" blocks, based on the phone state. + */ + private void updateCallInfoLayout(PhoneConstants.State state) { + boolean ringing = (state == PhoneConstants.State.RINGING); + if (DBG) log("updateCallInfoLayout()... ringing = " + ringing); + + // Based on the current state, update the overall + // CallCard layout: + + // - Update the bottom margin of mCallInfoContainer to make sure + // the call info area won't overlap with the touchable + // controls on the bottom part of the screen. + + int reservedVerticalSpace = mInCallScreen.getInCallTouchUi().getTouchUiHeight(); + ViewGroup.MarginLayoutParams callInfoLp = + (ViewGroup.MarginLayoutParams) mCallInfoContainer.getLayoutParams(); + callInfoLp.bottomMargin = reservedVerticalSpace; // Equivalent to setting + // android:layout_marginBottom in XML + if (DBG) log(" ==> callInfoLp.bottomMargin: " + reservedVerticalSpace); + mCallInfoContainer.setLayoutParams(callInfoLp); + } + + /** + * Updates the UI for the state where the phone is in use, but not ringing. + */ + private void updateForegroundCall(CallManager cm) { + if (DBG) log("updateForegroundCall()..."); + // if (DBG) PhoneUtils.dumpCallManager(); + + Call fgCall = cm.getActiveFgCall(); + Call bgCall = cm.getFirstActiveBgCall(); + + if (fgCall.getState() == Call.State.IDLE) { + if (DBG) log("updateForegroundCall: no active call, show holding call"); + // TODO: make sure this case agrees with the latest UI spec. + + // Display the background call in the main info area of the + // CallCard, since there is no foreground call. Note that + // displayMainCallStatus() will notice if the call we passed in is on + // hold, and display the "on hold" indication. + fgCall = bgCall; + + // And be sure to not display anything in the "on hold" box. + bgCall = null; + } + + displayMainCallStatus(cm, fgCall); + + Phone phone = fgCall.getPhone(); + + int phoneType = phone.getPhoneType(); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + if ((mApplication.cdmaPhoneCallState.getCurrentCallState() + == CdmaPhoneCallState.PhoneCallState.THRWAY_ACTIVE) + && mApplication.cdmaPhoneCallState.IsThreeWayCallOrigStateDialing()) { + displaySecondaryCallStatus(cm, fgCall); + } else { + //This is required so that even if a background call is not present + // we need to clean up the background call area. + displaySecondaryCallStatus(cm, bgCall); + } + } else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM) + || (phoneType == PhoneConstants.PHONE_TYPE_SIP)) { + displaySecondaryCallStatus(cm, bgCall); + } + } + + /** + * Updates the UI for the state where an incoming call is ringing (or + * call waiting), regardless of whether the phone's already offhook. + */ + private void updateRingingCall(CallManager cm) { + if (DBG) log("updateRingingCall()..."); + + Call ringingCall = cm.getFirstActiveRingingCall(); + + // Display caller-id info and photo from the incoming call: + displayMainCallStatus(cm, ringingCall); + + // And even in the Call Waiting case, *don't* show any info about + // the current ongoing call and/or the current call on hold. + // (Since the caller-id info for the incoming call totally trumps + // any info about the current call(s) in progress.) + displaySecondaryCallStatus(cm, null); + } + + /** + * Updates the UI for the state where an incoming call is just disconnected while we want to + * show the screen for a moment. + * + * This case happens when the whole in-call screen is in background when phone calls are hanged + * up, which means there's no way to determine which call was the last call finished. Right now + * this method simply shows the previous primary call status with a photo, closing the + * secondary call status. In most cases (including conference call or misc call happening in + * CDMA) this behaves right. + * + * If there were two phone calls both of which were hung up but the primary call was the + * first, this would behave a bit odd (since the first one still appears as the + * "last disconnected"). + */ + private void updateAlreadyDisconnected(CallManager cm) { + // For the foreground call, we manually set up every component based on previous state. + mPrimaryCallInfo.setVisibility(View.VISIBLE); + mSecondaryInfoContainer.setLayoutTransition(null); + mProviderInfo.setVisibility(View.GONE); + mCallStateLabel.setVisibility(View.VISIBLE); + mCallStateLabel.setText(mContext.getString(R.string.card_title_call_ended)); + mElapsedTime.setVisibility(View.VISIBLE); + mCallTime.cancelTimer(); + + // Just hide it. + displaySecondaryCallStatus(cm, null); + } + + /** + * Updates the UI for the state where the phone is not in use. + * This is analogous to updateForegroundCall() and updateRingingCall(), + * but for the (uncommon) case where the phone is + * totally idle. (See comments in updateState() above.) + * + * This puts the callcard into a sane but "blank" state. + */ + private void updateNoCall(CallManager cm) { + if (DBG) log("updateNoCall()..."); + + displayMainCallStatus(cm, null); + displaySecondaryCallStatus(cm, null); + } + + /** + * Updates the main block of caller info on the CallCard + * (ie. the stuff in the primaryCallInfo block) based on the specified Call. + */ + private void displayMainCallStatus(CallManager cm, Call call) { + if (DBG) log("displayMainCallStatus(call " + call + ")..."); + + if (call == null) { + // There's no call to display, presumably because the phone is idle. + mPrimaryCallInfo.setVisibility(View.GONE); + return; + } + mPrimaryCallInfo.setVisibility(View.VISIBLE); + + Call.State state = call.getState(); + if (DBG) log(" - call.state: " + call.getState()); + + switch (state) { + case ACTIVE: + case DISCONNECTING: + // update timer field + if (DBG) log("displayMainCallStatus: start periodicUpdateTimer"); + mCallTime.setActiveCallMode(call); + mCallTime.reset(); + mCallTime.periodicUpdateTimer(); + + break; + + case HOLDING: + // update timer field + mCallTime.cancelTimer(); + + break; + + case DISCONNECTED: + // Stop getting timer ticks from this call + mCallTime.cancelTimer(); + + break; + + case DIALING: + case ALERTING: + // Stop getting timer ticks from a previous call + mCallTime.cancelTimer(); + + break; + + case INCOMING: + case WAITING: + // Stop getting timer ticks from a previous call + mCallTime.cancelTimer(); + + break; + + case IDLE: + // The "main CallCard" should never be trying to display + // an idle call! In updateState(), if the phone is idle, + // we call updateNoCall(), which means that we shouldn't + // have passed a call into this method at all. + Log.w(LOG_TAG, "displayMainCallStatus: IDLE call in the main call card!"); + + // (It is possible, though, that we had a valid call which + // became idle *after* the check in updateState() but + // before we get here... So continue the best we can, + // with whatever (stale) info we can get from the + // passed-in Call object.) + + break; + + default: + Log.w(LOG_TAG, "displayMainCallStatus: unexpected call state: " + state); + break; + } + + updateCallStateWidgets(call); + + if (PhoneUtils.isConferenceCall(call)) { + // Update onscreen info for a conference call. + updateDisplayForConference(call); + } else { + // Update onscreen info for a regular call (which presumably + // has only one connection.) + Connection conn = null; + int phoneType = call.getPhone().getPhoneType(); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + conn = call.getLatestConnection(); + } else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM) + || (phoneType == PhoneConstants.PHONE_TYPE_SIP)) { + conn = call.getEarliestConnection(); + } else { + throw new IllegalStateException("Unexpected phone type: " + phoneType); + } + + if (conn == null) { + if (DBG) log("displayMainCallStatus: connection is null, using default values."); + // if the connection is null, we run through the behaviour + // we had in the past, which breaks down into trivial steps + // with the current implementation of getCallerInfo and + // updateDisplayForPerson. + CallerInfo info = PhoneUtils.getCallerInfo(getContext(), null /* conn */); + updateDisplayForPerson(info, PhoneConstants.PRESENTATION_ALLOWED, false, call, + conn); + } else { + if (DBG) log(" - CONN: " + conn + ", state = " + conn.getState()); + int presentation = conn.getNumberPresentation(); + + // make sure that we only make a new query when the current + // callerinfo differs from what we've been requested to display. + boolean runQuery = true; + Object o = conn.getUserData(); + if (o instanceof PhoneUtils.CallerInfoToken) { + runQuery = mPhotoTracker.isDifferentImageRequest( + ((PhoneUtils.CallerInfoToken) o).currentInfo); + } else { + runQuery = mPhotoTracker.isDifferentImageRequest(conn); + } + + // Adding a check to see if the update was caused due to a Phone number update + // or CNAP update. If so then we need to start a new query + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + Object obj = conn.getUserData(); + String updatedNumber = conn.getAddress(); + String updatedCnapName = conn.getCnapName(); + CallerInfo info = null; + if (obj instanceof PhoneUtils.CallerInfoToken) { + info = ((PhoneUtils.CallerInfoToken) o).currentInfo; + } else if (o instanceof CallerInfo) { + info = (CallerInfo) o; + } + + if (info != null) { + if (updatedNumber != null && !updatedNumber.equals(info.phoneNumber)) { + if (DBG) log("- displayMainCallStatus: updatedNumber = " + + updatedNumber); + runQuery = true; + } + if (updatedCnapName != null && !updatedCnapName.equals(info.cnapName)) { + if (DBG) log("- displayMainCallStatus: updatedCnapName = " + + updatedCnapName); + runQuery = true; + } + } + } + + if (runQuery) { + if (DBG) log("- displayMainCallStatus: starting CallerInfo query..."); + PhoneUtils.CallerInfoToken info = + PhoneUtils.startGetCallerInfo(getContext(), conn, this, call); + updateDisplayForPerson(info.currentInfo, presentation, !info.isFinal, + call, conn); + } else { + // No need to fire off a new query. We do still need + // to update the display, though (since we might have + // previously been in the "conference call" state.) + if (DBG) log("- displayMainCallStatus: using data we already have..."); + if (o instanceof CallerInfo) { + CallerInfo ci = (CallerInfo) o; + // Update CNAP information if Phone state change occurred + ci.cnapName = conn.getCnapName(); + ci.numberPresentation = conn.getNumberPresentation(); + ci.namePresentation = conn.getCnapNamePresentation(); + if (DBG) log("- displayMainCallStatus: CNAP data from Connection: " + + "CNAP name=" + ci.cnapName + + ", Number/Name Presentation=" + ci.numberPresentation); + if (DBG) log(" ==> Got CallerInfo; updating display: ci = " + ci); + updateDisplayForPerson(ci, presentation, false, call, conn); + } else if (o instanceof PhoneUtils.CallerInfoToken){ + CallerInfo ci = ((PhoneUtils.CallerInfoToken) o).currentInfo; + if (DBG) log("- displayMainCallStatus: CNAP data from Connection: " + + "CNAP name=" + ci.cnapName + + ", Number/Name Presentation=" + ci.numberPresentation); + if (DBG) log(" ==> Got CallerInfoToken; updating display: ci = " + ci); + updateDisplayForPerson(ci, presentation, true, call, conn); + } else { + Log.w(LOG_TAG, "displayMainCallStatus: runQuery was false, " + + "but we didn't have a cached CallerInfo object! o = " + o); + // TODO: any easy way to recover here (given that + // the CallCard is probably displaying stale info + // right now?) Maybe force the CallCard into the + // "Unknown" state? + } + } + } + } + + // In some states we override the "photo" ImageView to be an + // indication of the current state, rather than displaying the + // regular photo as set above. + updatePhotoForCallState(call); + + // One special feature of the "number" text field: For incoming + // calls, while the user is dragging the RotarySelector widget, we + // use mPhoneNumber to display a hint like "Rotate to answer". + if (mIncomingCallWidgetHintTextResId != 0) { + // Display the hint! + mPhoneNumber.setText(mIncomingCallWidgetHintTextResId); + mPhoneNumber.setTextColor(getResources().getColor(mIncomingCallWidgetHintColorResId)); + mPhoneNumber.setVisibility(View.VISIBLE); + mLabel.setVisibility(View.GONE); + } + // If we don't have a hint to display, just don't touch + // mPhoneNumber and mLabel. (Their text / color / visibility have + // already been set correctly, by either updateDisplayForPerson() + // or updateDisplayForConference().) + } + + /** + * Implemented for CallerInfoAsyncQuery.OnQueryCompleteListener interface. + * refreshes the CallCard data when it called. + */ + @Override + public void onQueryComplete(int token, Object cookie, CallerInfo ci) { + if (DBG) log("onQueryComplete: token " + token + ", cookie " + cookie + ", ci " + ci); + + if (cookie instanceof Call) { + // grab the call object and update the display for an individual call, + // as well as the successive call to update image via call state. + // If the object is a textview instead, we update it as we need to. + if (DBG) log("callerinfo query complete, updating ui from displayMainCallStatus()"); + Call call = (Call) cookie; + Connection conn = null; + int phoneType = call.getPhone().getPhoneType(); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + conn = call.getLatestConnection(); + } else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM) + || (phoneType == PhoneConstants.PHONE_TYPE_SIP)) { + conn = call.getEarliestConnection(); + } else { + throw new IllegalStateException("Unexpected phone type: " + phoneType); + } + PhoneUtils.CallerInfoToken cit = + PhoneUtils.startGetCallerInfo(getContext(), conn, this, null); + + int presentation = PhoneConstants.PRESENTATION_ALLOWED; + if (conn != null) presentation = conn.getNumberPresentation(); + if (DBG) log("- onQueryComplete: presentation=" + presentation + + ", contactExists=" + ci.contactExists); + + // Depending on whether there was a contact match or not, we want to pass in different + // CallerInfo (for CNAP). Therefore if ci.contactExists then use the ci passed in. + // Otherwise, regenerate the CIT from the Connection and use the CallerInfo from there. + if (ci.contactExists) { + updateDisplayForPerson(ci, PhoneConstants.PRESENTATION_ALLOWED, false, call, conn); + } else { + updateDisplayForPerson(cit.currentInfo, presentation, false, call, conn); + } + updatePhotoForCallState(call); + + } else if (cookie instanceof TextView){ + if (DBG) log("callerinfo query complete, updating ui from ongoing or onhold"); + ((TextView) cookie).setText(PhoneUtils.getCompactNameFromCallerInfo(ci, mContext)); + } + } + + /** + * Implemented for ContactsAsyncHelper.OnImageLoadCompleteListener interface. + * make sure that the call state is reflected after the image is loaded. + */ + @Override + public void onImageLoadComplete(int token, Drawable photo, Bitmap photoIcon, Object cookie) { + mHandler.removeMessages(MESSAGE_SHOW_UNKNOWN_PHOTO); + if (mLoadingPersonUri != null) { + // Start sending view notification after the current request being done. + // New image may possibly be available from the next phone calls. + // + // TODO: may be nice to update the image view again once the newer one + // is available on contacts database. + PhoneUtils.sendViewNotificationAsync(mApplication, mLoadingPersonUri); + } else { + // This should not happen while we need some verbose info if it happens.. + Log.w(LOG_TAG, "Person Uri isn't available while Image is successfully loaded."); + } + mLoadingPersonUri = null; + + AsyncLoadCookie asyncLoadCookie = (AsyncLoadCookie) cookie; + CallerInfo callerInfo = asyncLoadCookie.callerInfo; + ImageView imageView = asyncLoadCookie.imageView; + Call call = asyncLoadCookie.call; + + callerInfo.cachedPhoto = photo; + callerInfo.cachedPhotoIcon = photoIcon; + callerInfo.isCachedPhotoCurrent = true; + + // Note: previously ContactsAsyncHelper has done this job. + // TODO: We will need fade-in animation. See issue 5236130. + if (photo != null) { + showImage(imageView, photo); + } else if (photoIcon != null) { + showImage(imageView, photoIcon); + } else { + showImage(imageView, R.drawable.picture_unknown); + } + + if (token == TOKEN_UPDATE_PHOTO_FOR_CALL_STATE) { + updatePhotoForCallState(call); + } + } + + /** + * Updates the "call state label" and the elapsed time widget based on the + * current state of the call. + */ + private void updateCallStateWidgets(Call call) { + if (DBG) log("updateCallStateWidgets(call " + call + ")..."); + final Call.State state = call.getState(); + final Context context = getContext(); + final Phone phone = call.getPhone(); + final int phoneType = phone.getPhoneType(); + + String callStateLabel = null; // Label to display as part of the call banner + int bluetoothIconId = 0; // Icon to display alongside the call state label + + switch (state) { + case IDLE: + // "Call state" is meaningless in this state. + break; + + case ACTIVE: + // We normally don't show a "call state label" at all in + // this state (but see below for some special cases). + break; + + case HOLDING: + callStateLabel = context.getString(R.string.card_title_on_hold); + break; + + case DIALING: + case ALERTING: + callStateLabel = context.getString(R.string.card_title_dialing); + break; + + case INCOMING: + case WAITING: + callStateLabel = context.getString(R.string.card_title_incoming_call); + + // Also, display a special icon (alongside the "Incoming call" + // label) if there's an incoming call and audio will be routed + // to bluetooth when you answer it. + if (mApplication.showBluetoothIndication()) { + bluetoothIconId = R.drawable.ic_incoming_call_bluetooth; + } + break; + + case DISCONNECTING: + // While in the DISCONNECTING state we display a "Hanging up" + // message in order to make the UI feel more responsive. (In + // GSM it's normal to see a delay of a couple of seconds while + // negotiating the disconnect with the network, so the "Hanging + // up" state at least lets the user know that we're doing + // something. This state is currently not used with CDMA.) + callStateLabel = context.getString(R.string.card_title_hanging_up); + break; + + case DISCONNECTED: + callStateLabel = getCallFailedString(call); + break; + + default: + Log.wtf(LOG_TAG, "updateCallStateWidgets: unexpected call state: " + state); + break; + } + + // Check a couple of other special cases (these are all CDMA-specific). + + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + if ((state == Call.State.ACTIVE) + && mApplication.cdmaPhoneCallState.IsThreeWayCallOrigStateDialing()) { + // Display "Dialing" while dialing a 3Way call, even + // though the foreground call state is actually ACTIVE. + callStateLabel = context.getString(R.string.card_title_dialing); + } else if (PhoneGlobals.getInstance().notifier.getIsCdmaRedialCall()) { + callStateLabel = context.getString(R.string.card_title_redialing); + } + } + if (PhoneUtils.isPhoneInEcm(phone)) { + // In emergency callback mode (ECM), use a special label + // that shows your own phone number. + callStateLabel = getECMCardTitle(context, phone); + } + + final InCallUiState inCallUiState = mApplication.inCallUiState; + if (DBG) { + log("==> callStateLabel: '" + callStateLabel + + "', bluetoothIconId = " + bluetoothIconId + + ", providerInfoVisible = " + inCallUiState.providerInfoVisible); + } + + // Animation will be done by mCallerDetail's LayoutTransition, but in some cases, we don't + // want that. + // - DIALING: This is at the beginning of the phone call. + // - DISCONNECTING, DISCONNECTED: Screen will disappear soon; we have no time for animation. + final boolean skipAnimation = (state == Call.State.DIALING + || state == Call.State.DISCONNECTING + || state == Call.State.DISCONNECTED); + LayoutTransition layoutTransition = null; + if (skipAnimation) { + // Evict LayoutTransition object to skip animation. + layoutTransition = mSecondaryInfoContainer.getLayoutTransition(); + mSecondaryInfoContainer.setLayoutTransition(null); + } + + if (inCallUiState.providerInfoVisible) { + mProviderInfo.setVisibility(View.VISIBLE); + mProviderLabel.setText(context.getString(R.string.calling_via_template, + inCallUiState.providerLabel)); + mProviderAddress.setText(inCallUiState.providerAddress); + + mInCallScreen.requestRemoveProviderInfoWithDelay(); + } else { + mProviderInfo.setVisibility(View.GONE); + } + + if (!TextUtils.isEmpty(callStateLabel)) { + mCallStateLabel.setVisibility(View.VISIBLE); + mCallStateLabel.setText(callStateLabel); + + // ...and display the icon too if necessary. + if (bluetoothIconId != 0) { + mCallStateLabel.setCompoundDrawablesWithIntrinsicBounds(bluetoothIconId, 0, 0, 0); + mCallStateLabel.setCompoundDrawablePadding((int) (mDensity * 5)); + } else { + // Clear out any icons + mCallStateLabel.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0); + } + } else { + mCallStateLabel.setVisibility(View.GONE); + // Gravity is aligned left when receiving an incoming call in landscape. + // In that rare case, the gravity needs to be reset to the right. + // Also, setText("") is used since there is a delay in making the view GONE, + // so the user will otherwise see the text jump to the right side before disappearing. + if(mCallStateLabel.getGravity() != Gravity.END) { + mCallStateLabel.setText(""); + mCallStateLabel.setGravity(Gravity.END); + } + } + if (skipAnimation) { + // Restore LayoutTransition object to recover animation. + mSecondaryInfoContainer.setLayoutTransition(layoutTransition); + } + + // ...and update the elapsed time widget too. + switch (state) { + case ACTIVE: + case DISCONNECTING: + // Show the time with fade-in animation. + AnimationUtils.Fade.show(mElapsedTime); + updateElapsedTimeWidget(call); + break; + + case DISCONNECTED: + // In the "Call ended" state, leave the mElapsedTime widget + // visible, but don't touch it (so we continue to see the + // elapsed time of the call that just ended.) + // Check visibility to keep possible fade-in animation. + if (mElapsedTime.getVisibility() != View.VISIBLE) { + mElapsedTime.setVisibility(View.VISIBLE); + } + break; + + default: + // Call state here is IDLE, ACTIVE, HOLDING, DIALING, ALERTING, + // INCOMING, or WAITING. + // In all of these states, the "elapsed time" is meaningless, so + // don't show it. + AnimationUtils.Fade.hide(mElapsedTime, View.INVISIBLE); + + // Additionally, in call states that can only occur at the start + // of a call, reset the elapsed time to be sure we won't display + // stale info later (like if we somehow go straight from DIALING + // or ALERTING to DISCONNECTED, which can actually happen in + // some failure cases like "line busy"). + if ((state == Call.State.DIALING) || (state == Call.State.ALERTING)) { + updateElapsedTimeWidget(0); + } + + break; + } + } + + /** + * Updates mElapsedTime based on the given {@link Call} object's information. + * + * @see CallTime#getCallDuration(Call) + * @see Connection#getDurationMillis() + */ + /* package */ void updateElapsedTimeWidget(Call call) { + long duration = CallTime.getCallDuration(call); // msec + updateElapsedTimeWidget(duration / 1000); + // Also see onTickForCallTimeElapsed(), which updates this + // widget once per second while the call is active. + } + + /** + * Updates mElapsedTime based on the specified number of seconds. + */ + private void updateElapsedTimeWidget(long timeElapsed) { + // if (DBG) log("updateElapsedTimeWidget: " + timeElapsed); + mElapsedTime.setText(DateUtils.formatElapsedTime(timeElapsed)); + } + + /** + * Updates the "on hold" box in the "other call" info area + * (ie. the stuff in the secondaryCallInfo block) + * based on the specified Call. + * Or, clear out the "on hold" box if the specified call + * is null or idle. + */ + private void displaySecondaryCallStatus(CallManager cm, Call call) { + if (DBG) log("displayOnHoldCallStatus(call =" + call + ")..."); + + if ((call == null) || (PhoneGlobals.getInstance().isOtaCallInActiveState())) { + mSecondaryCallInfo.setVisibility(View.GONE); + return; + } + + Call.State state = call.getState(); + switch (state) { + case HOLDING: + // Ok, there actually is a background call on hold. + // Display the "on hold" box. + + // Note this case occurs only on GSM devices. (On CDMA, + // the "call on hold" is actually the 2nd connection of + // that ACTIVE call; see the ACTIVE case below.) + showSecondaryCallInfo(); + + if (PhoneUtils.isConferenceCall(call)) { + if (DBG) log("==> conference call."); + mSecondaryCallName.setText(getContext().getString(R.string.confCall)); + showImage(mSecondaryCallPhoto, R.drawable.picture_conference); + } else { + // perform query and update the name temporarily + // make sure we hand the textview we want updated to the + // callback function. + if (DBG) log("==> NOT a conf call; call startGetCallerInfo..."); + PhoneUtils.CallerInfoToken infoToken = PhoneUtils.startGetCallerInfo( + getContext(), call, this, mSecondaryCallName); + mSecondaryCallName.setText( + PhoneUtils.getCompactNameFromCallerInfo(infoToken.currentInfo, + getContext())); + + // Also pull the photo out of the current CallerInfo. + // (Note we assume we already have a valid photo at + // this point, since *presumably* the caller-id query + // was already run at some point *before* this call + // got put on hold. If there's no cached photo, just + // fall back to the default "unknown" image.) + if (infoToken.isFinal) { + showCachedImage(mSecondaryCallPhoto, infoToken.currentInfo); + } else { + showImage(mSecondaryCallPhoto, R.drawable.picture_unknown); + } + } + + AnimationUtils.Fade.show(mSecondaryCallPhotoDimEffect); + break; + + case ACTIVE: + // CDMA: This is because in CDMA when the user originates the second call, + // although the Foreground call state is still ACTIVE in reality the network + // put the first call on hold. + if (mApplication.phone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) { + showSecondaryCallInfo(); + + List<Connection> connections = call.getConnections(); + if (connections.size() > 2) { + // This means that current Mobile Originated call is the not the first 3-Way + // call the user is making, which in turn tells the PhoneGlobals that we no + // longer know which previous caller/party had dropped out before the user + // made this call. + mSecondaryCallName.setText( + getContext().getString(R.string.card_title_in_call)); + showImage(mSecondaryCallPhoto, R.drawable.picture_unknown); + } else { + // This means that the current Mobile Originated call IS the first 3-Way + // and hence we display the first callers/party's info here. + Connection conn = call.getEarliestConnection(); + PhoneUtils.CallerInfoToken infoToken = PhoneUtils.startGetCallerInfo( + getContext(), conn, this, mSecondaryCallName); + + // Get the compactName to be displayed, but then check that against + // the number presentation value for the call. If it's not an allowed + // presentation, then display the appropriate presentation string instead. + CallerInfo info = infoToken.currentInfo; + + String name = PhoneUtils.getCompactNameFromCallerInfo(info, getContext()); + boolean forceGenericPhoto = false; + if (info != null && info.numberPresentation != + PhoneConstants.PRESENTATION_ALLOWED) { + name = PhoneUtils.getPresentationString( + getContext(), info.numberPresentation); + forceGenericPhoto = true; + } + mSecondaryCallName.setText(name); + + // Also pull the photo out of the current CallerInfo. + // (Note we assume we already have a valid photo at + // this point, since *presumably* the caller-id query + // was already run at some point *before* this call + // got put on hold. If there's no cached photo, just + // fall back to the default "unknown" image.) + if (!forceGenericPhoto && infoToken.isFinal) { + showCachedImage(mSecondaryCallPhoto, info); + } else { + showImage(mSecondaryCallPhoto, R.drawable.picture_unknown); + } + } + } else { + // We shouldn't ever get here at all for non-CDMA devices. + Log.w(LOG_TAG, "displayOnHoldCallStatus: ACTIVE state on non-CDMA device"); + mSecondaryCallInfo.setVisibility(View.GONE); + } + + AnimationUtils.Fade.hide(mSecondaryCallPhotoDimEffect, View.GONE); + break; + + default: + // There's actually no call on hold. (Presumably this call's + // state is IDLE, since any other state is meaningless for the + // background call.) + mSecondaryCallInfo.setVisibility(View.GONE); + break; + } + } + + private void showSecondaryCallInfo() { + // This will call ViewStub#inflate() when needed. + mSecondaryCallInfo.setVisibility(View.VISIBLE); + if (mSecondaryCallName == null) { + mSecondaryCallName = (TextView) findViewById(R.id.secondaryCallName); + } + if (mSecondaryCallPhoto == null) { + mSecondaryCallPhoto = (ImageView) findViewById(R.id.secondaryCallPhoto); + } + if (mSecondaryCallPhotoDimEffect == null) { + mSecondaryCallPhotoDimEffect = findViewById(R.id.dim_effect_for_secondary_photo); + mSecondaryCallPhotoDimEffect.setOnClickListener(mInCallScreen); + // Add a custom OnTouchListener to manually shrink the "hit target". + mSecondaryCallPhotoDimEffect.setOnTouchListener(new SmallerHitTargetTouchListener()); + } + mInCallScreen.updateButtonStateOutsideInCallTouchUi(); + } + + /** + * Method which is expected to be called from + * {@link InCallScreen#updateButtonStateOutsideInCallTouchUi()}. + */ + /* package */ void setSecondaryCallClickable(boolean clickable) { + if (mSecondaryCallPhotoDimEffect != null) { + mSecondaryCallPhotoDimEffect.setEnabled(clickable); + } + } + + private String getCallFailedString(Call call) { + Connection c = call.getEarliestConnection(); + int resID; + + if (c == null) { + if (DBG) log("getCallFailedString: connection is null, using default values."); + // if this connection is null, just assume that the + // default case occurs. + resID = R.string.card_title_call_ended; + } else { + + Connection.DisconnectCause cause = c.getDisconnectCause(); + + // TODO: The card *title* should probably be "Call ended" in all + // cases, but if the DisconnectCause was an error condition we should + // probably also display the specific failure reason somewhere... + + switch (cause) { + case BUSY: + resID = R.string.callFailed_userBusy; + break; + + case CONGESTION: + resID = R.string.callFailed_congestion; + break; + + case TIMED_OUT: + resID = R.string.callFailed_timedOut; + break; + + case SERVER_UNREACHABLE: + resID = R.string.callFailed_server_unreachable; + break; + + case NUMBER_UNREACHABLE: + resID = R.string.callFailed_number_unreachable; + break; + + case INVALID_CREDENTIALS: + resID = R.string.callFailed_invalid_credentials; + break; + + case SERVER_ERROR: + resID = R.string.callFailed_server_error; + break; + + case OUT_OF_NETWORK: + resID = R.string.callFailed_out_of_network; + break; + + case LOST_SIGNAL: + case CDMA_DROP: + resID = R.string.callFailed_noSignal; + break; + + case LIMIT_EXCEEDED: + resID = R.string.callFailed_limitExceeded; + break; + + case POWER_OFF: + resID = R.string.callFailed_powerOff; + break; + + case ICC_ERROR: + resID = R.string.callFailed_simError; + break; + + case OUT_OF_SERVICE: + resID = R.string.callFailed_outOfService; + break; + + case INVALID_NUMBER: + case UNOBTAINABLE_NUMBER: + resID = R.string.callFailed_unobtainable_number; + break; + + default: + resID = R.string.card_title_call_ended; + break; + } + } + return getContext().getString(resID); + } + + /** + * Updates the name / photo / number / label fields on the CallCard + * based on the specified CallerInfo. + * + * If the current call is a conference call, use + * updateDisplayForConference() instead. + */ + private void updateDisplayForPerson(CallerInfo info, + int presentation, + boolean isTemporary, + Call call, + Connection conn) { + if (DBG) log("updateDisplayForPerson(" + info + ")\npresentation:" + + presentation + " isTemporary:" + isTemporary); + + // inform the state machine that we are displaying a photo. + mPhotoTracker.setPhotoRequest(info); + mPhotoTracker.setPhotoState(ContactsAsyncHelper.ImageTracker.DISPLAY_IMAGE); + + // The actual strings we're going to display onscreen: + String displayName; + String displayNumber = null; + String label = null; + Uri personUri = null; + // String socialStatusText = null; + // Drawable socialStatusBadge = null; + + // Gather missing info unless the call is generic, in which case we wouldn't use + // the gathered information anyway. + if (info != null && !call.isGeneric()) { + + // It appears that there is a small change in behaviour with the + // PhoneUtils' startGetCallerInfo whereby if we query with an + // empty number, we will get a valid CallerInfo object, but with + // fields that are all null, and the isTemporary boolean input + // parameter as true. + + // In the past, we would see a NULL callerinfo object, but this + // ends up causing null pointer exceptions elsewhere down the + // line in other cases, so we need to make this fix instead. It + // appears that this was the ONLY call to PhoneUtils + // .getCallerInfo() that relied on a NULL CallerInfo to indicate + // an unknown contact. + + // Currently, infi.phoneNumber may actually be a SIP address, and + // if so, it might sometimes include the "sip:" prefix. That + // prefix isn't really useful to the user, though, so strip it off + // if present. (For any other URI scheme, though, leave the + // prefix alone.) + // TODO: It would be cleaner for CallerInfo to explicitly support + // SIP addresses instead of overloading the "phoneNumber" field. + // Then we could remove this hack, and instead ask the CallerInfo + // for a "user visible" form of the SIP address. + String number = info.phoneNumber; + if ((number != null) && number.startsWith("sip:")) { + number = number.substring(4); + } + + if (TextUtils.isEmpty(info.name)) { + // No valid "name" in the CallerInfo, so fall back to + // something else. + // (Typically, we promote the phone number up to the "name" slot + // onscreen, and possibly display a descriptive string in the + // "number" slot.) + if (TextUtils.isEmpty(number)) { + // No name *or* number! Display a generic "unknown" string + // (or potentially some other default based on the presentation.) + displayName = PhoneUtils.getPresentationString(getContext(), presentation); + if (DBG) log(" ==> no name *or* number! displayName = " + displayName); + } else if (presentation != PhoneConstants.PRESENTATION_ALLOWED) { + // This case should never happen since the network should never send a phone # + // AND a restricted presentation. However we leave it here in case of weird + // network behavior + displayName = PhoneUtils.getPresentationString(getContext(), presentation); + if (DBG) log(" ==> presentation not allowed! displayName = " + displayName); + } else if (!TextUtils.isEmpty(info.cnapName)) { + // No name, but we do have a valid CNAP name, so use that. + displayName = info.cnapName; + info.name = info.cnapName; + displayNumber = number; + if (DBG) log(" ==> cnapName available: displayName '" + + displayName + "', displayNumber '" + displayNumber + "'"); + } else { + // No name; all we have is a number. This is the typical + // case when an incoming call doesn't match any contact, + // or if you manually dial an outgoing number using the + // dialpad. + + // Promote the phone number up to the "name" slot: + displayName = number; + + // ...and use the "number" slot for a geographical description + // string if available (but only for incoming calls.) + if ((conn != null) && (conn.isIncoming())) { + // TODO (CallerInfoAsyncQuery cleanup): Fix the CallerInfo + // query to only do the geoDescription lookup in the first + // place for incoming calls. + displayNumber = info.geoDescription; // may be null + } + + if (DBG) log(" ==> no name; falling back to number: displayName '" + + displayName + "', displayNumber '" + displayNumber + "'"); + } + } else { + // We do have a valid "name" in the CallerInfo. Display that + // in the "name" slot, and the phone number in the "number" slot. + if (presentation != PhoneConstants.PRESENTATION_ALLOWED) { + // This case should never happen since the network should never send a name + // AND a restricted presentation. However we leave it here in case of weird + // network behavior + displayName = PhoneUtils.getPresentationString(getContext(), presentation); + if (DBG) log(" ==> valid name, but presentation not allowed!" + + " displayName = " + displayName); + } else { + displayName = info.name; + displayNumber = number; + label = info.phoneLabel; + if (DBG) log(" ==> name is present in CallerInfo: displayName '" + + displayName + "', displayNumber '" + displayNumber + "'"); + } + } + personUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, info.person_id); + if (DBG) log("- got personUri: '" + personUri + + "', based on info.person_id: " + info.person_id); + } else { + displayName = PhoneUtils.getPresentationString(getContext(), presentation); + } + + if (call.isGeneric()) { + updateGenericInfoUi(); + } else { + updateInfoUi(displayName, displayNumber, label); + } + + // Update mPhoto + // if the temporary flag is set, we know we'll be getting another call after + // the CallerInfo has been correctly updated. So, we can skip the image + // loading until then. + + // If the photoResource is filled in for the CallerInfo, (like with the + // Emergency Number case), then we can just set the photo image without + // requesting for an image load. Please refer to CallerInfoAsyncQuery.java + // for cases where CallerInfo.photoResource may be set. We can also avoid + // the image load step if the image data is cached. + if (isTemporary && (info == null || !info.isCachedPhotoCurrent)) { + mPhoto.setTag(null); + mPhoto.setVisibility(View.INVISIBLE); + } else if (info != null && info.photoResource != 0){ + showImage(mPhoto, info.photoResource); + } else if (!showCachedImage(mPhoto, info)) { + if (personUri == null) { + Log.w(LOG_TAG, "personPri is null. Just use Unknown picture."); + showImage(mPhoto, R.drawable.picture_unknown); + } else if (personUri.equals(mLoadingPersonUri)) { + if (DBG) { + log("The requested Uri (" + personUri + ") is being loaded already." + + " Ignoret the duplicate load request."); + } + } else { + // Remember which person's photo is being loaded right now so that we won't issue + // unnecessary load request multiple times, which will mess up animation around + // the contact photo. + mLoadingPersonUri = personUri; + + // Forget the drawable previously used. + mPhoto.setTag(null); + // Show empty screen for a moment. + mPhoto.setVisibility(View.INVISIBLE); + // Load the image with a callback to update the image state. + // When the load is finished, onImageLoadComplete() will be called. + ContactsAsyncHelper.startObtainPhotoAsync(TOKEN_UPDATE_PHOTO_FOR_CALL_STATE, + getContext(), personUri, this, new AsyncLoadCookie(mPhoto, info, call)); + + // If the image load is too slow, we show a default avatar icon afterward. + // If it is fast enough, this message will be canceled on onImageLoadComplete(). + mHandler.removeMessages(MESSAGE_SHOW_UNKNOWN_PHOTO); + mHandler.sendEmptyMessageDelayed(MESSAGE_SHOW_UNKNOWN_PHOTO, MESSAGE_DELAY); + } + } + + // If the phone call is on hold, show it with darker status. + // Right now we achieve it by overlaying opaque View. + // Note: See also layout file about why so and what is the other possibilities. + if (call.getState() == Call.State.HOLDING) { + AnimationUtils.Fade.show(mPhotoDimEffect); + } else { + AnimationUtils.Fade.hide(mPhotoDimEffect, View.GONE); + } + + // Other text fields: + updateCallTypeLabel(call); + // updateSocialStatus(socialStatusText, socialStatusBadge, call); // Currently unused + } + + /** + * Updates the info portion of the UI to be generic. Used for CDMA 3-way calls. + */ + private void updateGenericInfoUi() { + mName.setText(R.string.card_title_in_call); + mPhoneNumber.setVisibility(View.GONE); + mLabel.setVisibility(View.GONE); + } + + /** + * Updates the info portion of the call card with passed in values. + */ + private void updateInfoUi(String displayName, String displayNumber, String label) { + mName.setText(displayName); + mName.setVisibility(View.VISIBLE); + + if (TextUtils.isEmpty(displayNumber)) { + mPhoneNumber.setVisibility(View.GONE); + // We have a real phone number as "mName" so make it always LTR + mName.setTextDirection(View.TEXT_DIRECTION_LTR); + } else { + mPhoneNumber.setText(displayNumber); + mPhoneNumber.setVisibility(View.VISIBLE); + // We have a real phone number as "mPhoneNumber" so make it always LTR + mPhoneNumber.setTextDirection(View.TEXT_DIRECTION_LTR); + } + + if (TextUtils.isEmpty(label)) { + mLabel.setVisibility(View.GONE); + } else { + mLabel.setText(label); + mLabel.setVisibility(View.VISIBLE); + } + } + + /** + * Updates the name / photo / number / label fields + * for the special "conference call" state. + * + * If the current call has only a single connection, use + * updateDisplayForPerson() instead. + */ + private void updateDisplayForConference(Call call) { + if (DBG) log("updateDisplayForConference()..."); + + int phoneType = call.getPhone().getPhoneType(); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + // This state corresponds to both 3-Way merged call and + // Call Waiting accepted call. + // In this case we display the UI in a "generic" state, with + // the generic "dialing" icon and no caller information, + // because in this state in CDMA the user does not really know + // which caller party he is talking to. + showImage(mPhoto, R.drawable.picture_dialing); + mName.setText(R.string.card_title_in_call); + } else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM) + || (phoneType == PhoneConstants.PHONE_TYPE_SIP)) { + // Normal GSM (or possibly SIP?) conference call. + // Display the "conference call" image as the contact photo. + // TODO: Better visual treatment for contact photos in a + // conference call (see bug 1313252). + showImage(mPhoto, R.drawable.picture_conference); + mName.setText(R.string.card_title_conf_call); + } else { + throw new IllegalStateException("Unexpected phone type: " + phoneType); + } + + mName.setVisibility(View.VISIBLE); + + // TODO: For a conference call, the "phone number" slot is specced + // to contain a summary of who's on the call, like "Bill Foldes + // and Hazel Nutt" or "Bill Foldes and 2 others". + // But for now, just hide it: + mPhoneNumber.setVisibility(View.GONE); + mLabel.setVisibility(View.GONE); + + // Other text fields: + updateCallTypeLabel(call); + // updateSocialStatus(null, null, null); // socialStatus is never visible in this state + + // TODO: for a GSM conference call, since we do actually know who + // you're talking to, consider also showing names / numbers / + // photos of some of the people on the conference here, so you can + // see that info without having to click "Manage conference". We + // probably have enough space to show info for 2 people, at least. + // + // To do this, our caller would pass us the activeConnections + // list, and we'd call PhoneUtils.getCallerInfo() separately for + // each connection. + } + + /** + * Updates the CallCard "photo" IFF the specified Call is in a state + * that needs a special photo (like "busy" or "dialing".) + * + * If the current call does not require a special image in the "photo" + * slot onscreen, don't do anything, since presumably the photo image + * has already been set (to the photo of the person we're talking, or + * the generic "picture_unknown" image, or the "conference call" + * image.) + */ + private void updatePhotoForCallState(Call call) { + if (DBG) log("updatePhotoForCallState(" + call + ")..."); + int photoImageResource = 0; + + // Check for the (relatively few) telephony states that need a + // special image in the "photo" slot. + Call.State state = call.getState(); + switch (state) { + case DISCONNECTED: + // Display the special "busy" photo for BUSY or CONGESTION. + // Otherwise (presumably the normal "call ended" state) + // leave the photo alone. + Connection c = call.getEarliestConnection(); + // if the connection is null, we assume the default case, + // otherwise update the image resource normally. + if (c != null) { + Connection.DisconnectCause cause = c.getDisconnectCause(); + if ((cause == Connection.DisconnectCause.BUSY) + || (cause == Connection.DisconnectCause.CONGESTION)) { + photoImageResource = R.drawable.picture_busy; + } + } else if (DBG) { + log("updatePhotoForCallState: connection is null, ignoring."); + } + + // TODO: add special images for any other DisconnectCauses? + break; + + case ALERTING: + case DIALING: + default: + // Leave the photo alone in all other states. + // If this call is an individual call, and the image is currently + // displaying a state, (rather than a photo), we'll need to update + // the image. + // This is for the case where we've been displaying the state and + // now we need to restore the photo. This can happen because we + // only query the CallerInfo once, and limit the number of times + // the image is loaded. (So a state image may overwrite the photo + // and we would otherwise have no way of displaying the photo when + // the state goes away.) + + // if the photoResource field is filled-in in the Connection's + // caller info, then we can just use that instead of requesting + // for a photo load. + + // look for the photoResource if it is available. + CallerInfo ci = null; + { + Connection conn = null; + int phoneType = call.getPhone().getPhoneType(); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + conn = call.getLatestConnection(); + } else if ((phoneType == PhoneConstants.PHONE_TYPE_GSM) + || (phoneType == PhoneConstants.PHONE_TYPE_SIP)) { + conn = call.getEarliestConnection(); + } else { + throw new IllegalStateException("Unexpected phone type: " + phoneType); + } + + if (conn != null) { + Object o = conn.getUserData(); + if (o instanceof CallerInfo) { + ci = (CallerInfo) o; + } else if (o instanceof PhoneUtils.CallerInfoToken) { + ci = ((PhoneUtils.CallerInfoToken) o).currentInfo; + } + } + } + + if (ci != null) { + photoImageResource = ci.photoResource; + } + + // If no photoResource found, check to see if this is a conference call. If + // it is not a conference call: + // 1. Try to show the cached image + // 2. If the image is not cached, check to see if a load request has been + // made already. + // 3. If the load request has not been made [DISPLAY_DEFAULT], start the + // request and note that it has started by updating photo state with + // [DISPLAY_IMAGE]. + if (photoImageResource == 0) { + if (!PhoneUtils.isConferenceCall(call)) { + if (!showCachedImage(mPhoto, ci) && (mPhotoTracker.getPhotoState() == + ContactsAsyncHelper.ImageTracker.DISPLAY_DEFAULT)) { + Uri photoUri = mPhotoTracker.getPhotoUri(); + if (photoUri == null) { + Log.w(LOG_TAG, "photoUri became null. Show default avatar icon"); + showImage(mPhoto, R.drawable.picture_unknown); + } else { + if (DBG) { + log("start asynchronous load inside updatePhotoForCallState()"); + } + mPhoto.setTag(null); + // Make it invisible for a moment + mPhoto.setVisibility(View.INVISIBLE); + ContactsAsyncHelper.startObtainPhotoAsync(TOKEN_DO_NOTHING, + getContext(), photoUri, this, + new AsyncLoadCookie(mPhoto, ci, null)); + } + mPhotoTracker.setPhotoState( + ContactsAsyncHelper.ImageTracker.DISPLAY_IMAGE); + } + } + } else { + showImage(mPhoto, photoImageResource); + mPhotoTracker.setPhotoState(ContactsAsyncHelper.ImageTracker.DISPLAY_IMAGE); + return; + } + break; + } + + if (photoImageResource != 0) { + if (DBG) log("- overrriding photo image: " + photoImageResource); + showImage(mPhoto, photoImageResource); + // Track the image state. + mPhotoTracker.setPhotoState(ContactsAsyncHelper.ImageTracker.DISPLAY_DEFAULT); + } + } + + /** + * Try to display the cached image from the callerinfo object. + * + * @return true if we were able to find the image in the cache, false otherwise. + */ + private static final boolean showCachedImage(ImageView view, CallerInfo ci) { + if ((ci != null) && ci.isCachedPhotoCurrent) { + if (ci.cachedPhoto != null) { + showImage(view, ci.cachedPhoto); + } else { + showImage(view, R.drawable.picture_unknown); + } + return true; + } + return false; + } + + /** Helper function to display the resource in the imageview AND ensure its visibility.*/ + private static final void showImage(ImageView view, int resource) { + showImage(view, view.getContext().getResources().getDrawable(resource)); + } + + private static final void showImage(ImageView view, Bitmap bitmap) { + showImage(view, new BitmapDrawable(view.getContext().getResources(), bitmap)); + } + + /** Helper function to display the drawable in the imageview AND ensure its visibility.*/ + private static final void showImage(ImageView view, Drawable drawable) { + Resources res = view.getContext().getResources(); + Drawable current = (Drawable) view.getTag(); + + if (current == null) { + if (DBG) log("Start fade-in animation for " + view); + view.setImageDrawable(drawable); + AnimationUtils.Fade.show(view); + view.setTag(drawable); + } else { + AnimationUtils.startCrossFade(view, current, drawable); + view.setVisibility(View.VISIBLE); + } + } + + /** + * Returns the special card title used in emergency callback mode (ECM), + * which shows your own phone number. + */ + private String getECMCardTitle(Context context, Phone phone) { + String rawNumber = phone.getLine1Number(); // may be null or empty + String formattedNumber; + if (!TextUtils.isEmpty(rawNumber)) { + formattedNumber = PhoneNumberUtils.formatNumber(rawNumber); + } else { + formattedNumber = context.getString(R.string.unknown); + } + String titleFormat = context.getString(R.string.card_title_my_phone_number); + return String.format(titleFormat, formattedNumber); + } + + /** + * Updates the "Call type" label, based on the current foreground call. + * This is a special label and/or branding we display for certain + * kinds of calls. + * + * (So far, this is used only for SIP calls, which get an + * "Internet call" label. TODO: But eventually, the telephony + * layer might allow each pluggable "provider" to specify a string + * and/or icon to be displayed here.) + */ + private void updateCallTypeLabel(Call call) { + int phoneType = (call != null) ? call.getPhone().getPhoneType() : + PhoneConstants.PHONE_TYPE_NONE; + if (phoneType == PhoneConstants.PHONE_TYPE_SIP) { + mCallTypeLabel.setVisibility(View.VISIBLE); + mCallTypeLabel.setText(R.string.incall_call_type_label_sip); + mCallTypeLabel.setTextColor(mTextColorCallTypeSip); + // If desired, we could also display a "badge" next to the label, as follows: + // mCallTypeLabel.setCompoundDrawablesWithIntrinsicBounds( + // callTypeSpecificBadge, null, null, null); + // mCallTypeLabel.setCompoundDrawablePadding((int) (mDensity * 6)); + } else { + mCallTypeLabel.setVisibility(View.GONE); + } + } + + /** + * Updates the "social status" label with the specified text and + * (optional) badge. + */ + /*private void updateSocialStatus(String socialStatusText, + Drawable socialStatusBadge, + Call call) { + // The socialStatus field is *only* visible while an incoming call + // is ringing, never in any other call state. + if ((socialStatusText != null) + && (call != null) + && call.isRinging() + && !call.isGeneric()) { + mSocialStatus.setVisibility(View.VISIBLE); + mSocialStatus.setText(socialStatusText); + mSocialStatus.setCompoundDrawablesWithIntrinsicBounds( + socialStatusBadge, null, null, null); + mSocialStatus.setCompoundDrawablePadding((int) (mDensity * 6)); + } else { + mSocialStatus.setVisibility(View.GONE); + } + }*/ + + /** + * Hides the top-level UI elements of the call card: The "main + * call card" element representing the current active or ringing call, + * and also the info areas for "ongoing" or "on hold" calls in some + * states. + * + * This is intended to be used in special states where the normal + * in-call UI is totally replaced by some other UI, like OTA mode on a + * CDMA device. + * + * To bring back the regular CallCard UI, just re-run the normal + * updateState() call sequence. + */ + public void hideCallCardElements() { + mPrimaryCallInfo.setVisibility(View.GONE); + mSecondaryCallInfo.setVisibility(View.GONE); + } + + /* + * Updates the hint (like "Rotate to answer") that we display while + * the user is dragging the incoming call RotarySelector widget. + */ + /* package */ void setIncomingCallWidgetHint(int hintTextResId, int hintColorResId) { + mIncomingCallWidgetHintTextResId = hintTextResId; + mIncomingCallWidgetHintColorResId = hintColorResId; + } + + // Accessibility event support. + // Since none of the CallCard elements are focusable, we need to manually + // fill in the AccessibilityEvent here (so that the name / number / etc will + // get pronounced by a screen reader, for example.) + @Override + public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) { + if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) { + dispatchPopulateAccessibilityEvent(event, mName); + dispatchPopulateAccessibilityEvent(event, mPhoneNumber); + return true; + } + + dispatchPopulateAccessibilityEvent(event, mCallStateLabel); + dispatchPopulateAccessibilityEvent(event, mPhoto); + dispatchPopulateAccessibilityEvent(event, mName); + dispatchPopulateAccessibilityEvent(event, mPhoneNumber); + dispatchPopulateAccessibilityEvent(event, mLabel); + // dispatchPopulateAccessibilityEvent(event, mSocialStatus); + if (mSecondaryCallName != null) { + dispatchPopulateAccessibilityEvent(event, mSecondaryCallName); + } + if (mSecondaryCallPhoto != null) { + dispatchPopulateAccessibilityEvent(event, mSecondaryCallPhoto); + } + return true; + } + + private void dispatchPopulateAccessibilityEvent(AccessibilityEvent event, View view) { + List<CharSequence> eventText = event.getText(); + int size = eventText.size(); + view.dispatchPopulateAccessibilityEvent(event); + // if no text added write null to keep relative position + if (size == eventText.size()) { + eventText.add(null); + } + } + + public void clear() { + // The existing phone design is to keep an instance of call card forever. Until that + // design changes, this method is needed to clear (reset) the call card for the next call + // so old data is not shown. + + // Other elements can also be cleared here. Starting with elapsed time to fix a bug. + mElapsedTime.setVisibility(View.GONE); + mElapsedTime.setText(null); + } + + + // Debugging / testing code + + private static void log(String msg) { + Log.d(LOG_TAG, msg); + } +} |