InCallUI/src/com/android/incallui/ExternalCallNotifier.java - platform/packages/apps/Dialer - Gitiles

 /*
  * Copyright (C) 2016 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 com.google.common.base.Preconditions;

 import com.android.contacts.common.ContactsUtils;
 import com.android.contacts.common.compat.CallSdkCompat;
 import com.android.contacts.common.preference.ContactsPreferences;
 import com.android.contacts.common.util.BitmapUtil;
 import com.android.contacts.common.util.ContactDisplayUtils;
 import com.android.dialer.R;
 import com.android.incallui.util.TelecomCallUtil;

 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.drawable.BitmapDrawable;
 import android.net.Uri;
 import android.support.annotation.Nullable;
 import android.telecom.Call;
 import android.telecom.PhoneAccount;
 import android.text.BidiFormatter;
 import android.text.TextDirectionHeuristics;
 import android.text.TextUtils;
 import android.util.ArrayMap;

 import java.util.Map;

 /**
  * Handles the display of notifications for "external calls".
  *
  * External calls are a representation of a call which is in progress on the user's other device
  * (e.g. another phone, or a watch).
  */
 public class ExternalCallNotifier implements ExternalCallList.ExternalCallListener {

     /**
      * Tag used with the notification manager to uniquely identify external call notifications.
      */
     private static final String NOTIFICATION_TAG = "EXTERNAL_CALL";

     /**
      * Represents a call and associated cached notification data.
      */
     private static class NotificationInfo {
         private final Call mCall;
         private final int mNotificationId;
         @Nullable private String mContentTitle;
         @Nullable private Bitmap mLargeIcon;
         @Nullable private String mPersonReference;

         public NotificationInfo(Call call, int notificationId) {
             Preconditions.checkNotNull(call);
             mCall = call;
             mNotificationId = notificationId;
         }

         public Call getCall() {
             return mCall;
         }

         public int getNotificationId() {
             return mNotificationId;
         }

         public @Nullable String getContentTitle() {
             return mContentTitle;
         }

         public @Nullable Bitmap getLargeIcon() {
             return mLargeIcon;
         }

         public @Nullable String getPersonReference() {
             return mPersonReference;
         }

         public void setContentTitle(@Nullable String contentTitle) {
             mContentTitle = contentTitle;
         }

         public void setLargeIcon(@Nullable Bitmap largeIcon) {
             mLargeIcon = largeIcon;
         }

         public void setPersonReference(@Nullable String personReference) {
             mPersonReference = personReference;
         }
     }

     private final Context mContext;
     private final ContactInfoCache mContactInfoCache;
     private Map<Call, NotificationInfo> mNotifications = new ArrayMap<>();
     private int mNextUniqueNotificationId;
     private ContactsPreferences mContactsPreferences;

     /**
      * Initializes a new instance of the external call notifier.
      */
     public ExternalCallNotifier(Context context, ContactInfoCache contactInfoCache) {
         mContext = Preconditions.checkNotNull(context);
         mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
         mContactInfoCache = Preconditions.checkNotNull(contactInfoCache);
     }

     /**
      * Handles the addition of a new external call by showing a new notification.
      * Triggered by {@link CallList#onCallAdded(android.telecom.Call)}.
      */
     @Override
     public void onExternalCallAdded(android.telecom.Call call) {
         Log.i(this, "onExternalCallAdded " + call);
         Preconditions.checkArgument(!mNotifications.containsKey(call));
         NotificationInfo info = new NotificationInfo(call, mNextUniqueNotificationId++);
         mNotifications.put(call, info);

         showNotifcation(info);
     }

     /**
      * Handles the removal of an external call by hiding its associated notification.
      * Triggered by {@link CallList#onCallRemoved(android.telecom.Call)}.
      */
     @Override
     public void onExternalCallRemoved(android.telecom.Call call) {
         Log.i(this, "onExternalCallRemoved " + call);

         dismissNotification(call);
     }

     /**
      * Handles updates to an external call.
      */
     @Override
     public void onExternalCallUpdated(Call call) {
         Preconditions.checkArgument(mNotifications.containsKey(call));
         postNotification(mNotifications.get(call));
     }

     /**
      * Initiates a call pull given a notification ID.
      *
      * @param notificationId The notification ID associated with the external call which is to be
      *                       pulled.
      */
     public void pullExternalCall(int notificationId) {
         for (NotificationInfo info : mNotifications.values()) {
             if (info.getNotificationId() == notificationId) {
                 CallSdkCompat.pullExternalCall(info.getCall());
                 return;
             }
         }
     }

     /**
      * Shows a notification for a new external call.  Performs a contact cache lookup to find any
      * associated photo and information for the call.
      */
     private void showNotifcation(final NotificationInfo info) {
         // We make a call to the contact info cache to query for supplemental data to what the
         // call provides.  This includes the contact name and photo.
         // This callback will always get called immediately and synchronously with whatever data
         // it has available, and may make a subsequent call later (same thread) if it had to
         // call into the contacts provider for more data.
         com.android.incallui.Call incallCall = new com.android.incallui.Call(info.getCall(),
                 new LatencyReport(), false /* registerCallback */);

         mContactInfoCache.findInfo(incallCall, false /* isIncoming */,
                 new ContactInfoCache.ContactInfoCacheCallback() {
                     @Override
                     public void onContactInfoComplete(String callId,
                             ContactInfoCache.ContactCacheEntry entry) {

                         // Ensure notification still exists as the external call could have been
                         // removed during async contact info lookup.
                         if (mNotifications.containsKey(info.getCall())) {
                             saveContactInfo(info, entry);
                         }
                     }

                     @Override
                     public void onImageLoadComplete(String callId,
                             ContactInfoCache.ContactCacheEntry entry) {

                         // Ensure notification still exists as the external call could have been
                         // removed during async contact info lookup.
                         if (mNotifications.containsKey(info.getCall())) {
                             savePhoto(info, entry);
                         }
                     }

                     @Override
                     public void onContactInteractionsInfoComplete(String callId,
                             ContactInfoCache.ContactCacheEntry entry) {
                     }
                 });
     }

     /**
      * Dismisses a notification for an external call.
      */
     private void dismissNotification(Call call) {
         Preconditions.checkArgument(mNotifications.containsKey(call));

         NotificationManager notificationManager =
                 (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
         notificationManager.cancel(NOTIFICATION_TAG, mNotifications.get(call).getNotificationId());

         mNotifications.remove(call);
     }

     /**
      * Attempts to build a large icon to use for the notification based on the contact info and
      * post the updated notification to the notification manager.
      */
     private void savePhoto(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
         Bitmap largeIcon = getLargeIconToDisplay(mContext, entry, info.getCall());
         if (largeIcon != null) {
             largeIcon = getRoundedIcon(mContext, largeIcon);
         }
         info.setLargeIcon(largeIcon);
         postNotification(info);
     }

     /**
      * Builds and stores the contact information the notification will display and posts the updated
      * notification to the notification manager.
      */
     private void saveContactInfo(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
         info.setContentTitle(getContentTitle(mContext, mContactsPreferences,
                 entry, info.getCall()));
         info.setPersonReference(getPersonReference(entry, info.getCall()));
         postNotification(info);
     }

     /**
      * Rebuild an existing or show a new notification given {@link NotificationInfo}.
      */
     private void postNotification(NotificationInfo info) {
         Log.i(this, "postNotification : " + info.getContentTitle());
         Notification.Builder builder = new Notification.Builder(mContext);
         // Set notification as ongoing since calls are long-running versus a point-in-time notice.
         builder.setOngoing(true);
         // Make the notification prioritized over the other normal notifications.
         builder.setPriority(Notification.PRIORITY_HIGH);
         // Set the content ("Ongoing call on another device")
         builder.setContentText(mContext.getString(R.string.notification_external_call));
         builder.setSmallIcon(R.drawable.ic_call_white_24dp);
         builder.setContentTitle(info.getContentTitle());
         builder.setLargeIcon(info.getLargeIcon());
         builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
         builder.addPerson(info.getPersonReference());

         // Where the external call supports being transferred to the local device, add an action
         // to the notification to initiate the call pull process.
         if ((info.getCall().getDetails().getCallCapabilities()
                 & CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL)
                 == CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL) {

             Intent intent = new Intent(
                     NotificationBroadcastReceiver.ACTION_PULL_EXTERNAL_CALL, null, mContext,
                     NotificationBroadcastReceiver.class);
             intent.putExtra(NotificationBroadcastReceiver.EXTRA_NOTIFICATION_ID,
                     info.getNotificationId());

             builder.addAction(new Notification.Action.Builder(R.drawable.ic_call_white_24dp,
                     mContext.getText(R.string.notification_transfer_call),
                     PendingIntent.getBroadcast(mContext, 0, intent, 0)).build());
         }

         /**
          * This builder is used for the notification shown when the device is locked and the user
          * has set their notification settings to 'hide sensitive content'
          * {@see Notification.Builder#setPublicVersion}.
          */
         Notification.Builder publicBuilder = new Notification.Builder(mContext);
         publicBuilder.setSmallIcon(R.drawable.ic_call_white_24dp);
         publicBuilder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));

         builder.setPublicVersion(publicBuilder.build());
         Notification notification = builder.build();

         NotificationManager notificationManager =
                 (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
         notificationManager.notify(NOTIFICATION_TAG, info.getNotificationId(), notification);
     }

     /**
      * Finds a large icon to display in a notification for a call.  For conference calls, a
      * conference call icon is used, otherwise if contact info is specified, the user's contact
      * photo or avatar is used.
      *
      * @param context The context.
      * @param contactInfo The contact cache info.
      * @param call The call.
      * @return The large icon to use for the notification.
      */
     private @Nullable Bitmap getLargeIconToDisplay(Context context,
             ContactInfoCache.ContactCacheEntry contactInfo, android.telecom.Call call) {

         Bitmap largeIcon = null;
         if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE) &&
                 !call.getDetails()
                         .hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {

             largeIcon = BitmapFactory.decodeResource(context.getResources(),
                     R.drawable.img_conference);
         }
         if (contactInfo.photo != null && (contactInfo.photo instanceof BitmapDrawable)) {
             largeIcon = ((BitmapDrawable) contactInfo.photo).getBitmap();
         }
         return largeIcon;
     }

     /**
      * Given a bitmap, returns a rounded version of the icon suitable for display in a notification.
      *
      * @param context The context.
      * @param bitmap The bitmap to round.
      * @return The rounded bitmap.
      */
     private @Nullable Bitmap getRoundedIcon(Context context, @Nullable Bitmap bitmap) {
         if (bitmap == null) {
             return null;
         }
         final int height = (int) context.getResources().getDimension(
                 android.R.dimen.notification_large_icon_height);
         final int width = (int) context.getResources().getDimension(
                 android.R.dimen.notification_large_icon_width);
         return BitmapUtil.getRoundedBitmap(bitmap, width, height);
     }

     /**
      * Builds a notification content title for a call.  If the call is a conference call, it is
      * identified as such.  Otherwise an attempt is made to show an associated contact name or
      * phone number.
      *
      * @param context The context.
      * @param contactsPreferences Contacts preferences, used to determine the preferred formatting
      *                            for contact names.
      * @param contactInfo The contact info which was looked up in the contact cache.
      * @param call The call to generate a title for.
      * @return The content title.
      */
     private @Nullable String getContentTitle(Context context,
             @Nullable ContactsPreferences contactsPreferences,
             ContactInfoCache.ContactCacheEntry contactInfo, android.telecom.Call call) {

         if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE) &&
                 !call.getDetails()
                         .hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {

             return context.getResources().getString(R.string.card_title_conf_call);
         }

         String preferredName = ContactDisplayUtils.getPreferredDisplayName(contactInfo.namePrimary,
                 contactInfo.nameAlternative, contactsPreferences);
         if (TextUtils.isEmpty(preferredName)) {
             return TextUtils.isEmpty(contactInfo.number) ? null : BidiFormatter.getInstance()
                     .unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR);
         }
         return preferredName;
     }

     /**
      * Gets a "person reference" for a notification, used by the system to determine whether the
      * notification should be allowed past notification interruption filters.
      *
      * @param contactInfo The contact info from cache.
      * @param call The call.
      * @return the person reference.
      */
     private String getPersonReference(ContactInfoCache.ContactCacheEntry contactInfo,
             Call call) {

         String number = TelecomCallUtil.getNumber(call);
         // Query {@link Contacts#CONTENT_LOOKUP_URI} directly with work lookup key is not allowed.
         // So, do not pass {@link Contacts#CONTENT_LOOKUP_URI} to NotificationManager to avoid
         // NotificationManager using it.
         if (contactInfo.lookupUri != null && contactInfo.userType != ContactsUtils.USER_TYPE_WORK) {
             return contactInfo.lookupUri.toString();
         } else if (!TextUtils.isEmpty(number)) {
             return Uri.fromParts(PhoneAccount.SCHEME_TEL, number, null).toString();
         }
         return "";
     }
 }
	/*
	* Copyright (C) 2016 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 com.google.common.base.Preconditions;

	import com.android.contacts.common.ContactsUtils;
	import com.android.contacts.common.compat.CallSdkCompat;
	import com.android.contacts.common.preference.ContactsPreferences;
	import com.android.contacts.common.util.BitmapUtil;
	import com.android.contacts.common.util.ContactDisplayUtils;
	import com.android.dialer.R;
	import com.android.incallui.util.TelecomCallUtil;

	import android.app.Notification;
	import android.app.NotificationManager;
	import android.app.PendingIntent;
	import android.content.Context;
	import android.content.Intent;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.drawable.BitmapDrawable;
	import android.net.Uri;
	import android.support.annotation.Nullable;
	import android.telecom.Call;
	import android.telecom.PhoneAccount;
	import android.text.BidiFormatter;
	import android.text.TextDirectionHeuristics;
	import android.text.TextUtils;
	import android.util.ArrayMap;

	import java.util.Map;

	/**
	* Handles the display of notifications for "external calls".
	*
	* External calls are a representation of a call which is in progress on the user's other device
	* (e.g. another phone, or a watch).
	*/
	public class ExternalCallNotifier implements ExternalCallList.ExternalCallListener {

	/**
	* Tag used with the notification manager to uniquely identify external call notifications.
	*/
	private static final String NOTIFICATION_TAG = "EXTERNAL_CALL";

	/**
	* Represents a call and associated cached notification data.
	*/
	private static class NotificationInfo {
	private final Call mCall;
	private final int mNotificationId;
	@Nullable private String mContentTitle;
	@Nullable private Bitmap mLargeIcon;
	@Nullable private String mPersonReference;

	public NotificationInfo(Call call, int notificationId) {
	Preconditions.checkNotNull(call);
	mCall = call;
	mNotificationId = notificationId;
	}

	public Call getCall() {
	return mCall;
	}

	public int getNotificationId() {
	return mNotificationId;
	}

	public @Nullable String getContentTitle() {
	return mContentTitle;
	}

	public @Nullable Bitmap getLargeIcon() {
	return mLargeIcon;
	}

	public @Nullable String getPersonReference() {
	return mPersonReference;
	}

	public void setContentTitle(@Nullable String contentTitle) {
	mContentTitle = contentTitle;
	}

	public void setLargeIcon(@Nullable Bitmap largeIcon) {
	mLargeIcon = largeIcon;
	}

	public void setPersonReference(@Nullable String personReference) {
	mPersonReference = personReference;
	}
	}

	private final Context mContext;
	private final ContactInfoCache mContactInfoCache;
	private Map<Call, NotificationInfo> mNotifications = new ArrayMap<>();
	private int mNextUniqueNotificationId;
	private ContactsPreferences mContactsPreferences;

	/**
	* Initializes a new instance of the external call notifier.
	*/
	public ExternalCallNotifier(Context context, ContactInfoCache contactInfoCache) {
	mContext = Preconditions.checkNotNull(context);
	mContactsPreferences = ContactsPreferencesFactory.newContactsPreferences(mContext);
	mContactInfoCache = Preconditions.checkNotNull(contactInfoCache);
	}

	/**
	* Handles the addition of a new external call by showing a new notification.
	* Triggered by {@link CallList#onCallAdded(android.telecom.Call)}.
	*/
	@Override
	public void onExternalCallAdded(android.telecom.Call call) {
	Log.i(this, "onExternalCallAdded " + call);
	Preconditions.checkArgument(!mNotifications.containsKey(call));
	NotificationInfo info = new NotificationInfo(call, mNextUniqueNotificationId++);
	mNotifications.put(call, info);

	showNotifcation(info);
	}

	/**
	* Handles the removal of an external call by hiding its associated notification.
	* Triggered by {@link CallList#onCallRemoved(android.telecom.Call)}.
	*/
	@Override
	public void onExternalCallRemoved(android.telecom.Call call) {
	Log.i(this, "onExternalCallRemoved " + call);

	dismissNotification(call);
	}

	/**
	* Handles updates to an external call.
	*/
	@Override
	public void onExternalCallUpdated(Call call) {
	Preconditions.checkArgument(mNotifications.containsKey(call));
	postNotification(mNotifications.get(call));
	}

	/**
	* Initiates a call pull given a notification ID.
	*
	* @param notificationId The notification ID associated with the external call which is to be
	* pulled.
	*/
	public void pullExternalCall(int notificationId) {
	for (NotificationInfo info : mNotifications.values()) {
	if (info.getNotificationId() == notificationId) {
	CallSdkCompat.pullExternalCall(info.getCall());
	return;
	}
	}
	}

	/**
	* Shows a notification for a new external call. Performs a contact cache lookup to find any
	* associated photo and information for the call.
	*/
	private void showNotifcation(final NotificationInfo info) {
	// We make a call to the contact info cache to query for supplemental data to what the
	// call provides. This includes the contact name and photo.
	// This callback will always get called immediately and synchronously with whatever data
	// it has available, and may make a subsequent call later (same thread) if it had to
	// call into the contacts provider for more data.
	com.android.incallui.Call incallCall = new com.android.incallui.Call(info.getCall(),
	new LatencyReport(), false /* registerCallback */);

	mContactInfoCache.findInfo(incallCall, false /* isIncoming */,
	new ContactInfoCache.ContactInfoCacheCallback() {
	@Override
	public void onContactInfoComplete(String callId,
	ContactInfoCache.ContactCacheEntry entry) {

	// Ensure notification still exists as the external call could have been
	// removed during async contact info lookup.
	if (mNotifications.containsKey(info.getCall())) {
	saveContactInfo(info, entry);
	}
	}

	@Override
	public void onImageLoadComplete(String callId,
	ContactInfoCache.ContactCacheEntry entry) {

	// Ensure notification still exists as the external call could have been
	// removed during async contact info lookup.
	if (mNotifications.containsKey(info.getCall())) {
	savePhoto(info, entry);
	}
	}

	@Override
	public void onContactInteractionsInfoComplete(String callId,
	ContactInfoCache.ContactCacheEntry entry) {
	}
	});
	}

	/**
	* Dismisses a notification for an external call.
	*/
	private void dismissNotification(Call call) {
	Preconditions.checkArgument(mNotifications.containsKey(call));

	NotificationManager notificationManager =
	(NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
	notificationManager.cancel(NOTIFICATION_TAG, mNotifications.get(call).getNotificationId());

	mNotifications.remove(call);
	}

	/**
	* Attempts to build a large icon to use for the notification based on the contact info and
	* post the updated notification to the notification manager.
	*/
	private void savePhoto(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
	Bitmap largeIcon = getLargeIconToDisplay(mContext, entry, info.getCall());
	if (largeIcon != null) {
	largeIcon = getRoundedIcon(mContext, largeIcon);
	}
	info.setLargeIcon(largeIcon);
	postNotification(info);
	}

	/**
	* Builds and stores the contact information the notification will display and posts the updated
	* notification to the notification manager.
	*/
	private void saveContactInfo(NotificationInfo info, ContactInfoCache.ContactCacheEntry entry) {
	info.setContentTitle(getContentTitle(mContext, mContactsPreferences,
	entry, info.getCall()));
	info.setPersonReference(getPersonReference(entry, info.getCall()));
	postNotification(info);
	}

	/**
	* Rebuild an existing or show a new notification given {@link NotificationInfo}.
	*/
	private void postNotification(NotificationInfo info) {
	Log.i(this, "postNotification : " + info.getContentTitle());
	Notification.Builder builder = new Notification.Builder(mContext);
	// Set notification as ongoing since calls are long-running versus a point-in-time notice.
	builder.setOngoing(true);
	// Make the notification prioritized over the other normal notifications.
	builder.setPriority(Notification.PRIORITY_HIGH);
	// Set the content ("Ongoing call on another device")
	builder.setContentText(mContext.getString(R.string.notification_external_call));
	builder.setSmallIcon(R.drawable.ic_call_white_24dp);
	builder.setContentTitle(info.getContentTitle());
	builder.setLargeIcon(info.getLargeIcon());
	builder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));
	builder.addPerson(info.getPersonReference());

	// Where the external call supports being transferred to the local device, add an action
	// to the notification to initiate the call pull process.
	if ((info.getCall().getDetails().getCallCapabilities()
	& CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL)
	== CallSdkCompat.Details.CAPABILITY_CAN_PULL_CALL) {

	Intent intent = new Intent(
	NotificationBroadcastReceiver.ACTION_PULL_EXTERNAL_CALL, null, mContext,
	NotificationBroadcastReceiver.class);
	intent.putExtra(NotificationBroadcastReceiver.EXTRA_NOTIFICATION_ID,
	info.getNotificationId());

	builder.addAction(new Notification.Action.Builder(R.drawable.ic_call_white_24dp,
	mContext.getText(R.string.notification_transfer_call),
	PendingIntent.getBroadcast(mContext, 0, intent, 0)).build());
	}

	/**
	* This builder is used for the notification shown when the device is locked and the user
	* has set their notification settings to 'hide sensitive content'
	* {@see Notification.Builder#setPublicVersion}.
	*/
	Notification.Builder publicBuilder = new Notification.Builder(mContext);
	publicBuilder.setSmallIcon(R.drawable.ic_call_white_24dp);
	publicBuilder.setColor(mContext.getResources().getColor(R.color.dialer_theme_color));

	builder.setPublicVersion(publicBuilder.build());
	Notification notification = builder.build();

	NotificationManager notificationManager =
	(NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
	notificationManager.notify(NOTIFICATION_TAG, info.getNotificationId(), notification);
	}

	/**
	* Finds a large icon to display in a notification for a call. For conference calls, a
	* conference call icon is used, otherwise if contact info is specified, the user's contact
	* photo or avatar is used.
	*
	* @param context The context.
	* @param contactInfo The contact cache info.
	* @param call The call.
	* @return The large icon to use for the notification.
	*/
	private @Nullable Bitmap getLargeIconToDisplay(Context context,
	ContactInfoCache.ContactCacheEntry contactInfo, android.telecom.Call call) {

	Bitmap largeIcon = null;
	if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE) &&
	!call.getDetails()
	.hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {

	largeIcon = BitmapFactory.decodeResource(context.getResources(),
	R.drawable.img_conference);
	}
	if (contactInfo.photo != null && (contactInfo.photo instanceof BitmapDrawable)) {
	largeIcon = ((BitmapDrawable) contactInfo.photo).getBitmap();
	}
	return largeIcon;
	}

	/**
	* Given a bitmap, returns a rounded version of the icon suitable for display in a notification.
	*
	* @param context The context.
	* @param bitmap The bitmap to round.
	* @return The rounded bitmap.
	*/
	private @Nullable Bitmap getRoundedIcon(Context context, @Nullable Bitmap bitmap) {
	if (bitmap == null) {
	return null;
	}
	final int height = (int) context.getResources().getDimension(
	android.R.dimen.notification_large_icon_height);
	final int width = (int) context.getResources().getDimension(
	android.R.dimen.notification_large_icon_width);
	return BitmapUtil.getRoundedBitmap(bitmap, width, height);
	}

	/**
	* Builds a notification content title for a call. If the call is a conference call, it is
	* identified as such. Otherwise an attempt is made to show an associated contact name or
	* phone number.
	*
	* @param context The context.
	* @param contactsPreferences Contacts preferences, used to determine the preferred formatting
	* for contact names.
	* @param contactInfo The contact info which was looked up in the contact cache.
	* @param call The call to generate a title for.
	* @return The content title.
	*/
	private @Nullable String getContentTitle(Context context,
	@Nullable ContactsPreferences contactsPreferences,
	ContactInfoCache.ContactCacheEntry contactInfo, android.telecom.Call call) {

	if (call.getDetails().hasProperty(android.telecom.Call.Details.PROPERTY_CONFERENCE) &&
	!call.getDetails()
	.hasProperty(android.telecom.Call.Details.PROPERTY_GENERIC_CONFERENCE)) {

	return context.getResources().getString(R.string.card_title_conf_call);
	}

	String preferredName = ContactDisplayUtils.getPreferredDisplayName(contactInfo.namePrimary,
	contactInfo.nameAlternative, contactsPreferences);
	if (TextUtils.isEmpty(preferredName)) {
	return TextUtils.isEmpty(contactInfo.number) ? null : BidiFormatter.getInstance()
	.unicodeWrap(contactInfo.number, TextDirectionHeuristics.LTR);
	}
	return preferredName;
	}

	/**
	* Gets a "person reference" for a notification, used by the system to determine whether the
	* notification should be allowed past notification interruption filters.
	*
	* @param contactInfo The contact info from cache.
	* @param call The call.
	* @return the person reference.
	*/
	private String getPersonReference(ContactInfoCache.ContactCacheEntry contactInfo,
	Call call) {

	String number = TelecomCallUtil.getNumber(call);
	// Query {@link Contacts#CONTENT_LOOKUP_URI} directly with work lookup key is not allowed.
	// So, do not pass {@link Contacts#CONTENT_LOOKUP_URI} to NotificationManager to avoid
	// NotificationManager using it.
	if (contactInfo.lookupUri != null && contactInfo.userType != ContactsUtils.USER_TYPE_WORK) {
	return contactInfo.lookupUri.toString();
	} else if (!TextUtils.isEmpty(number)) {
	return Uri.fromParts(PhoneAccount.SCHEME_TEL, number, null).toString();
	}
	return "";
	}
	}