src/com/android/phone/callcomposer/CallComposerPictureManager.java - platform/packages/services/Telephony - Git at Google

 /*
  * Copyright (C) 2020 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.callcomposer;

 import android.content.Context;
 import android.location.Location;
 import android.net.Uri;
 import android.os.OutcomeReceiver;
 import android.os.PersistableBundle;
 import android.os.UserHandle;
 import android.provider.CallLog;
 import android.telephony.CarrierConfigManager;
 import android.telephony.TelephonyManager;
 import android.telephony.gba.UaSecurityProtocolIdentifier;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.Pair;
 import android.util.SparseArray;

 import androidx.annotation.NonNull;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.phone.R;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;

 public class CallComposerPictureManager {
     private static final String TAG = CallComposerPictureManager.class.getSimpleName();
     private static final SparseArray<CallComposerPictureManager> sInstances = new SparseArray<>();
     private static final String THREE_GPP_BOOTSTRAPPING = "3GPP-bootstrapping";

     public static CallComposerPictureManager getInstance(Context context, int subscriptionId) {
         synchronized (sInstances) {
             if (sExecutorService == null) {
                 sExecutorService = Executors.newSingleThreadScheduledExecutor();
             }
             if (!sInstances.contains(subscriptionId)) {
                 sInstances.put(subscriptionId,
                         new CallComposerPictureManager(context, subscriptionId));
             }
             return sInstances.get(subscriptionId);
         }
     }

     @VisibleForTesting
     public static void clearInstances() {
         synchronized (sInstances) {
             sInstances.clear();
             if (sExecutorService != null) {
                 sExecutorService.shutdown();
                 sExecutorService = null;
             }
         }
     }

     // disabled provisionally until the auth stack is fully operational
     @VisibleForTesting
     public static boolean sTestMode = false;
     public static final String FAKE_SERVER_URL = "https://example.com/FAKE.png";
     public static final String FAKE_SUBJECT = "This is a test call subject";
     public static final Location FAKE_LOCATION = new Location("");
     static {
         // Meteor Crater, AZ
         FAKE_LOCATION.setLatitude(35.027526);
         FAKE_LOCATION.setLongitude(-111.021696);
     }

     public interface CallLogProxy {
         default void storeCallComposerPictureAsUser(Context context,
                 UserHandle user,
                 InputStream input,
                 Executor executor,
                 OutcomeReceiver<Uri, CallLog.CallComposerLoggingException> callback) {
             CallLog.storeCallComposerPicture(context.createContextAsUser(user, 0),
                     input, executor, callback);
         }
     }

     private static ScheduledExecutorService sExecutorService = null;

     private final HashMap<UUID, String> mCachedServerUrls = new HashMap<>();
     private final HashMap<UUID, ImageData> mCachedImages = new HashMap<>();
     private GbaCredentials mCachedCredentials = null;
     private final int mSubscriptionId;
     private final TelephonyManager mTelephonyManager;
     private final Context mContext;
     private CallLogProxy mCallLogProxy = new CallLogProxy() {};

     private CallComposerPictureManager(Context context, int subscriptionId) {
         mContext = context;
         mSubscriptionId = subscriptionId;
         mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
                 .createForSubscriptionId(mSubscriptionId);
     }

     public void handleUploadToServer(CallComposerPictureTransfer.Factory transferFactory,
             ImageData imageData, Consumer<Pair<UUID, Integer>> callback) {
         if (sTestMode) {
             UUID id = UUID.randomUUID();
             mCachedImages.put(id, imageData);
             mCachedServerUrls.put(id, FAKE_SERVER_URL);
             callback.accept(Pair.create(id, TelephonyManager.CallComposerException.SUCCESS));
             return;
         }

         PersistableBundle carrierConfig = mTelephonyManager.getCarrierConfig();
         String uploadUrl = carrierConfig.getString(
                 CarrierConfigManager.KEY_CALL_COMPOSER_PICTURE_SERVER_URL_STRING);
         if (TextUtils.isEmpty(uploadUrl)) {
             Log.e(TAG, "Call composer upload URL not configured in carrier config");
             callback.accept(Pair.create(null,
                     TelephonyManager.CallComposerException.ERROR_UNKNOWN));
         }
         UUID id = UUID.randomUUID();
         imageData.setId(id.toString());

         CallComposerPictureTransfer transfer = transferFactory.create(mContext,
                 mSubscriptionId, uploadUrl, sExecutorService);

         AtomicBoolean hasRetried = new AtomicBoolean(false);
         transfer.setCallback(new CallComposerPictureTransfer.PictureCallback() {
             @Override
             public void onError(int error) {
                 callback.accept(Pair.create(null, error));
             }

             @Override
             public void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {
                 if (hasRetried.getAndSet(true)) {
                     Log.e(TAG, "Giving up on image upload after one retry.");
                     callback.accept(Pair.create(null,
                             TelephonyManager.CallComposerException.ERROR_NETWORK_UNAVAILABLE));
                     return;
                 }
                 GbaCredentialsSupplier supplier =
                         (realm, executor) ->
                                 getGbaCredentials(credentialRefresh, carrierConfig, executor);

                 sExecutorService.schedule(() -> transfer.uploadPicture(imageData, supplier),
                         backoffMillis, TimeUnit.MILLISECONDS);
             }

             @Override
             public void onUploadSuccessful(String serverUrl) {
                 mCachedServerUrls.put(id, serverUrl);
                 mCachedImages.put(id, imageData);
                 Log.i(TAG, "Successfully received url: " + serverUrl + " associated with "
                         + id.toString());
                 callback.accept(Pair.create(id, TelephonyManager.CallComposerException.SUCCESS));
             }
         });

         transfer.uploadPicture(imageData,
                 (realm, executor) -> getGbaCredentials(false, carrierConfig, executor));
     }

     public void handleDownloadFromServer(CallComposerPictureTransfer.Factory transferFactory,
             String remoteUrl, Consumer<Pair<Uri, Integer>> callback) {
         if (sTestMode) {
             ImageData imageData = new ImageData(getPlaceholderPictureAsBytes(), "image/png", null);
             UUID id = UUID.randomUUID();
             mCachedImages.put(id, imageData);
             storeUploadedPictureToCallLog(id, uri -> callback.accept(Pair.create(uri, -1)));
             return;
         }

         PersistableBundle carrierConfig = mTelephonyManager.getCarrierConfig();
         CallComposerPictureTransfer transfer = transferFactory.create(mContext,
                 mSubscriptionId, remoteUrl, sExecutorService);

         AtomicBoolean hasRetried = new AtomicBoolean(false);
         transfer.setCallback(new CallComposerPictureTransfer.PictureCallback() {
             @Override
             public void onError(int error) {
                 callback.accept(Pair.create(null, error));
             }

             @Override
             public void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {
                 if (hasRetried.getAndSet(true)) {
                     Log.e(TAG, "Giving up on image download after one retry.");
                     callback.accept(Pair.create(null,
                             TelephonyManager.CallComposerException.ERROR_NETWORK_UNAVAILABLE));
                     return;
                 }
                 GbaCredentialsSupplier supplier =
                         (realm, executor) ->
                                 getGbaCredentials(credentialRefresh, carrierConfig, executor);

                 sExecutorService.schedule(() -> transfer.downloadPicture(supplier),
                         backoffMillis, TimeUnit.MILLISECONDS);
             }

             @Override
             public void onDownloadSuccessful(ImageData data) {
                 ByteArrayInputStream imageDataInput =
                         new ByteArrayInputStream(data.getImageBytes());
                 mCallLogProxy.storeCallComposerPictureAsUser(
                         mContext, UserHandle.CURRENT, imageDataInput,
                         sExecutorService,
                         new OutcomeReceiver<Uri, CallLog.CallComposerLoggingException>() {
                             @Override
                             public void onResult(@NonNull Uri result) {
                                 callback.accept(Pair.create(
                                         result, TelephonyManager.CallComposerException.SUCCESS));
                             }

                             @Override
                             public void onError(CallLog.CallComposerLoggingException e) {
                                 // Just report an error to the client for now.
                                 callback.accept(Pair.create(null,
                                         TelephonyManager.CallComposerException.ERROR_UNKNOWN));
                             }
                         });
             }
         });

         transfer.downloadPicture(((realm, executor) ->
                 getGbaCredentials(false, carrierConfig, executor)));
     }

     public void storeUploadedPictureToCallLog(UUID id, Consumer<Uri> callback) {
         ImageData data = mCachedImages.get(id);
         if (data == null) {
             Log.e(TAG, "No picture associated with uuid " + id);
             callback.accept(null);
             return;
         }
         ByteArrayInputStream imageDataInput =
                 new ByteArrayInputStream(data.getImageBytes());
         mCallLogProxy.storeCallComposerPictureAsUser(mContext, UserHandle.CURRENT, imageDataInput,
                 sExecutorService,
                 new OutcomeReceiver<Uri, CallLog.CallComposerLoggingException>() {
                     @Override
                     public void onResult(@NonNull Uri result) {
                         callback.accept(result);
                         clearCachedData();
                     }

                     @Override
                     public void onError(CallLog.CallComposerLoggingException e) {
                         // Just report an error to the client for now.
                         Log.e(TAG, "Error logging uploaded image: " + e.getErrorCode());
                         callback.accept(null);
                         clearCachedData();
                     }
                 });
     }

     public String getServerUrlForImageId(UUID id) {
         return mCachedServerUrls.get(id);
     }

     public void clearCachedData() {
         mCachedServerUrls.clear();
         mCachedImages.clear();
     }

     private byte[] getPlaceholderPictureAsBytes() {
         InputStream resourceInput = mContext.getResources().openRawResource(R.drawable.cupcake);
         try {
             return readBytes(resourceInput);
         } catch (Exception e) {
             return new byte[] {};
         }
     }

     private static byte[] readBytes(InputStream inputStream) throws Exception {
         byte[] buffer = new byte[1024];
         ByteArrayOutputStream output = new ByteArrayOutputStream();
         int numRead;
         do {
             numRead = inputStream.read(buffer);
             if (numRead > 0) output.write(buffer, 0, numRead);
         } while (numRead > 0);
         return output.toByteArray();
     }

     private CompletableFuture<GbaCredentials> getGbaCredentials(
             boolean forceRefresh, PersistableBundle config, Executor executor) {
         synchronized (this) {
             if (!forceRefresh && mCachedCredentials != null) {
                 return CompletableFuture.completedFuture(mCachedCredentials);
             }

             if (forceRefresh) {
                 mCachedCredentials = null;
             }
         }

         UaSecurityProtocolIdentifier securityProtocolIdentifier =
                 new UaSecurityProtocolIdentifier.Builder()
                         .setOrg(config.getInt(
                                 CarrierConfigManager.KEY_GBA_UA_SECURITY_ORGANIZATION_INT))
                         .setProtocol(config.getInt(
                                 CarrierConfigManager.KEY_GBA_UA_SECURITY_PROTOCOL_INT))
                         .setTlsCipherSuite(config.getInt(
                                 CarrierConfigManager.KEY_GBA_UA_TLS_CIPHER_SUITE_INT))
                         .build();
         CompletableFuture<GbaCredentials> resultFuture = new CompletableFuture<>();

         mTelephonyManager.bootstrapAuthenticationRequest(TelephonyManager.APPTYPE_ISIM,
                 getNafUri(config), securityProtocolIdentifier, forceRefresh, executor,
                 new TelephonyManager.BootstrapAuthenticationCallback() {
                     @Override
                     public void onKeysAvailable(byte[] gbaKey, String transactionId) {
                         GbaCredentials creds = new GbaCredentials(transactionId, gbaKey);
                         synchronized (CallComposerPictureManager.this) {
                             mCachedCredentials = creds;
                         }
                         resultFuture.complete(creds);
                     }

                     @Override
                     public void onAuthenticationFailure(int reason) {
                         Log.e(TAG, "GBA auth failed: reason=" + reason);
                         resultFuture.complete(null);
                     }
                 });

         return resultFuture;
     }

     private static Uri getNafUri(PersistableBundle carrierConfig) {
         String uploadUriString = carrierConfig.getString(
                 CarrierConfigManager.KEY_CALL_COMPOSER_PICTURE_SERVER_URL_STRING);
         Uri uploadUri = Uri.parse(uploadUriString);
         String nafPrefix;
         switch (carrierConfig.getInt(CarrierConfigManager.KEY_GBA_MODE_INT)) {
             case CarrierConfigManager.GBA_U:
                 nafPrefix = THREE_GPP_BOOTSTRAPPING + "-uicc";
                 break;
             case CarrierConfigManager.GBA_DIGEST:
                 nafPrefix = THREE_GPP_BOOTSTRAPPING + "-digest";
                 break;
             case CarrierConfigManager.GBA_ME:
             default:
                 nafPrefix = THREE_GPP_BOOTSTRAPPING;
         }
         String newAuthority = nafPrefix + "@" + uploadUri.getAuthority();
         Uri nafUri = new Uri.Builder().scheme(uploadUri.getScheme())
                 .encodedAuthority(newAuthority)
                 .build();
         Log.i(TAG, "using NAF uri " + nafUri + " for GBA");
         return nafUri;
     }

     @VisibleForTesting
     static ScheduledExecutorService getExecutor() {
         return sExecutorService;
     }

     @VisibleForTesting
     void setCallLogProxy(CallLogProxy proxy) {
         mCallLogProxy = proxy;
     }
 }
	/*
	* Copyright (C) 2020 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.callcomposer;

	import android.content.Context;
	import android.location.Location;
	import android.net.Uri;
	import android.os.OutcomeReceiver;
	import android.os.PersistableBundle;
	import android.os.UserHandle;
	import android.provider.CallLog;
	import android.telephony.CarrierConfigManager;
	import android.telephony.TelephonyManager;
	import android.telephony.gba.UaSecurityProtocolIdentifier;
	import android.text.TextUtils;
	import android.util.Log;
	import android.util.Pair;
	import android.util.SparseArray;

	import androidx.annotation.NonNull;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.phone.R;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.InputStream;
	import java.util.HashMap;
	import java.util.UUID;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.Executor;
	import java.util.concurrent.Executors;
	import java.util.concurrent.ScheduledExecutorService;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.function.Consumer;

	public class CallComposerPictureManager {
	private static final String TAG = CallComposerPictureManager.class.getSimpleName();
	private static final SparseArray<CallComposerPictureManager> sInstances = new SparseArray<>();
	private static final String THREE_GPP_BOOTSTRAPPING = "3GPP-bootstrapping";

	public static CallComposerPictureManager getInstance(Context context, int subscriptionId) {
	synchronized (sInstances) {
	if (sExecutorService == null) {
	sExecutorService = Executors.newSingleThreadScheduledExecutor();
	}
	if (!sInstances.contains(subscriptionId)) {
	sInstances.put(subscriptionId,
	new CallComposerPictureManager(context, subscriptionId));
	}
	return sInstances.get(subscriptionId);
	}
	}

	@VisibleForTesting
	public static void clearInstances() {
	synchronized (sInstances) {
	sInstances.clear();
	if (sExecutorService != null) {
	sExecutorService.shutdown();
	sExecutorService = null;
	}
	}
	}

	// disabled provisionally until the auth stack is fully operational
	@VisibleForTesting
	public static boolean sTestMode = false;
	public static final String FAKE_SERVER_URL = "https://example.com/FAKE.png";
	public static final String FAKE_SUBJECT = "This is a test call subject";
	public static final Location FAKE_LOCATION = new Location("");
	static {
	// Meteor Crater, AZ
	FAKE_LOCATION.setLatitude(35.027526);
	FAKE_LOCATION.setLongitude(-111.021696);
	}

	public interface CallLogProxy {
	default void storeCallComposerPictureAsUser(Context context,
	UserHandle user,
	InputStream input,
	Executor executor,
	OutcomeReceiver<Uri, CallLog.CallComposerLoggingException> callback) {
	CallLog.storeCallComposerPicture(context.createContextAsUser(user, 0),
	input, executor, callback);
	}
	}

	private static ScheduledExecutorService sExecutorService = null;

	private final HashMap<UUID, String> mCachedServerUrls = new HashMap<>();
	private final HashMap<UUID, ImageData> mCachedImages = new HashMap<>();
	private GbaCredentials mCachedCredentials = null;
	private final int mSubscriptionId;
	private final TelephonyManager mTelephonyManager;
	private final Context mContext;
	private CallLogProxy mCallLogProxy = new CallLogProxy() {};

	private CallComposerPictureManager(Context context, int subscriptionId) {
	mContext = context;
	mSubscriptionId = subscriptionId;
	mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
	.createForSubscriptionId(mSubscriptionId);
	}

	public void handleUploadToServer(CallComposerPictureTransfer.Factory transferFactory,
	ImageData imageData, Consumer<Pair<UUID, Integer>> callback) {
	if (sTestMode) {
	UUID id = UUID.randomUUID();
	mCachedImages.put(id, imageData);
	mCachedServerUrls.put(id, FAKE_SERVER_URL);
	callback.accept(Pair.create(id, TelephonyManager.CallComposerException.SUCCESS));
	return;
	}

	PersistableBundle carrierConfig = mTelephonyManager.getCarrierConfig();
	String uploadUrl = carrierConfig.getString(
	CarrierConfigManager.KEY_CALL_COMPOSER_PICTURE_SERVER_URL_STRING);
	if (TextUtils.isEmpty(uploadUrl)) {
	Log.e(TAG, "Call composer upload URL not configured in carrier config");
	callback.accept(Pair.create(null,
	TelephonyManager.CallComposerException.ERROR_UNKNOWN));
	}
	UUID id = UUID.randomUUID();
	imageData.setId(id.toString());

	CallComposerPictureTransfer transfer = transferFactory.create(mContext,
	mSubscriptionId, uploadUrl, sExecutorService);

	AtomicBoolean hasRetried = new AtomicBoolean(false);
	transfer.setCallback(new CallComposerPictureTransfer.PictureCallback() {
	@Override
	public void onError(int error) {
	callback.accept(Pair.create(null, error));
	}

	@Override
	public void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {
	if (hasRetried.getAndSet(true)) {
	Log.e(TAG, "Giving up on image upload after one retry.");
	callback.accept(Pair.create(null,
	TelephonyManager.CallComposerException.ERROR_NETWORK_UNAVAILABLE));
	return;
	}
	GbaCredentialsSupplier supplier =
	(realm, executor) ->
	getGbaCredentials(credentialRefresh, carrierConfig, executor);

	sExecutorService.schedule(() -> transfer.uploadPicture(imageData, supplier),
	backoffMillis, TimeUnit.MILLISECONDS);
	}

	@Override
	public void onUploadSuccessful(String serverUrl) {
	mCachedServerUrls.put(id, serverUrl);
	mCachedImages.put(id, imageData);
	Log.i(TAG, "Successfully received url: " + serverUrl + " associated with "
	+ id.toString());
	callback.accept(Pair.create(id, TelephonyManager.CallComposerException.SUCCESS));
	}
	});

	transfer.uploadPicture(imageData,
	(realm, executor) -> getGbaCredentials(false, carrierConfig, executor));
	}

	public void handleDownloadFromServer(CallComposerPictureTransfer.Factory transferFactory,
	String remoteUrl, Consumer<Pair<Uri, Integer>> callback) {
	if (sTestMode) {
	ImageData imageData = new ImageData(getPlaceholderPictureAsBytes(), "image/png", null);
	UUID id = UUID.randomUUID();
	mCachedImages.put(id, imageData);
	storeUploadedPictureToCallLog(id, uri -> callback.accept(Pair.create(uri, -1)));
	return;
	}

	PersistableBundle carrierConfig = mTelephonyManager.getCarrierConfig();
	CallComposerPictureTransfer transfer = transferFactory.create(mContext,
	mSubscriptionId, remoteUrl, sExecutorService);

	AtomicBoolean hasRetried = new AtomicBoolean(false);
	transfer.setCallback(new CallComposerPictureTransfer.PictureCallback() {
	@Override
	public void onError(int error) {
	callback.accept(Pair.create(null, error));
	}

	@Override
	public void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {
	if (hasRetried.getAndSet(true)) {
	Log.e(TAG, "Giving up on image download after one retry.");
	callback.accept(Pair.create(null,
	TelephonyManager.CallComposerException.ERROR_NETWORK_UNAVAILABLE));
	return;
	}
	GbaCredentialsSupplier supplier =
	(realm, executor) ->
	getGbaCredentials(credentialRefresh, carrierConfig, executor);

	sExecutorService.schedule(() -> transfer.downloadPicture(supplier),
	backoffMillis, TimeUnit.MILLISECONDS);
	}

	@Override
	public void onDownloadSuccessful(ImageData data) {
	ByteArrayInputStream imageDataInput =
	new ByteArrayInputStream(data.getImageBytes());
	mCallLogProxy.storeCallComposerPictureAsUser(
	mContext, UserHandle.CURRENT, imageDataInput,
	sExecutorService,
	new OutcomeReceiver<Uri, CallLog.CallComposerLoggingException>() {
	@Override
	public void onResult(@NonNull Uri result) {
	callback.accept(Pair.create(
	result, TelephonyManager.CallComposerException.SUCCESS));
	}

	@Override
	public void onError(CallLog.CallComposerLoggingException e) {
	// Just report an error to the client for now.
	callback.accept(Pair.create(null,
	TelephonyManager.CallComposerException.ERROR_UNKNOWN));
	}
	});
	}
	});

	transfer.downloadPicture(((realm, executor) ->
	getGbaCredentials(false, carrierConfig, executor)));
	}

	public void storeUploadedPictureToCallLog(UUID id, Consumer<Uri> callback) {
	ImageData data = mCachedImages.get(id);
	if (data == null) {
	Log.e(TAG, "No picture associated with uuid " + id);
	callback.accept(null);
	return;
	}
	ByteArrayInputStream imageDataInput =
	new ByteArrayInputStream(data.getImageBytes());
	mCallLogProxy.storeCallComposerPictureAsUser(mContext, UserHandle.CURRENT, imageDataInput,
	sExecutorService,
	new OutcomeReceiver<Uri, CallLog.CallComposerLoggingException>() {
	@Override
	public void onResult(@NonNull Uri result) {
	callback.accept(result);
	clearCachedData();
	}

	@Override
	public void onError(CallLog.CallComposerLoggingException e) {
	// Just report an error to the client for now.
	Log.e(TAG, "Error logging uploaded image: " + e.getErrorCode());
	callback.accept(null);
	clearCachedData();
	}
	});
	}

	public String getServerUrlForImageId(UUID id) {
	return mCachedServerUrls.get(id);
	}

	public void clearCachedData() {
	mCachedServerUrls.clear();
	mCachedImages.clear();
	}

	private byte[] getPlaceholderPictureAsBytes() {
	InputStream resourceInput = mContext.getResources().openRawResource(R.drawable.cupcake);
	try {
	return readBytes(resourceInput);
	} catch (Exception e) {
	return new byte[] {};
	}
	}

	private static byte[] readBytes(InputStream inputStream) throws Exception {
	byte[] buffer = new byte[1024];
	ByteArrayOutputStream output = new ByteArrayOutputStream();
	int numRead;
	do {
	numRead = inputStream.read(buffer);
	if (numRead > 0) output.write(buffer, 0, numRead);
	} while (numRead > 0);
	return output.toByteArray();
	}

	private CompletableFuture<GbaCredentials> getGbaCredentials(
	boolean forceRefresh, PersistableBundle config, Executor executor) {
	synchronized (this) {
	if (!forceRefresh && mCachedCredentials != null) {
	return CompletableFuture.completedFuture(mCachedCredentials);
	}

	if (forceRefresh) {
	mCachedCredentials = null;
	}
	}

	UaSecurityProtocolIdentifier securityProtocolIdentifier =
	new UaSecurityProtocolIdentifier.Builder()
	.setOrg(config.getInt(
	CarrierConfigManager.KEY_GBA_UA_SECURITY_ORGANIZATION_INT))
	.setProtocol(config.getInt(
	CarrierConfigManager.KEY_GBA_UA_SECURITY_PROTOCOL_INT))
	.setTlsCipherSuite(config.getInt(
	CarrierConfigManager.KEY_GBA_UA_TLS_CIPHER_SUITE_INT))
	.build();
	CompletableFuture<GbaCredentials> resultFuture = new CompletableFuture<>();

	mTelephonyManager.bootstrapAuthenticationRequest(TelephonyManager.APPTYPE_ISIM,
	getNafUri(config), securityProtocolIdentifier, forceRefresh, executor,
	new TelephonyManager.BootstrapAuthenticationCallback() {
	@Override
	public void onKeysAvailable(byte[] gbaKey, String transactionId) {
	GbaCredentials creds = new GbaCredentials(transactionId, gbaKey);
	synchronized (CallComposerPictureManager.this) {
	mCachedCredentials = creds;
	}
	resultFuture.complete(creds);
	}

	@Override
	public void onAuthenticationFailure(int reason) {
	Log.e(TAG, "GBA auth failed: reason=" + reason);
	resultFuture.complete(null);
	}
	});

	return resultFuture;
	}

	private static Uri getNafUri(PersistableBundle carrierConfig) {
	String uploadUriString = carrierConfig.getString(
	CarrierConfigManager.KEY_CALL_COMPOSER_PICTURE_SERVER_URL_STRING);
	Uri uploadUri = Uri.parse(uploadUriString);
	String nafPrefix;
	switch (carrierConfig.getInt(CarrierConfigManager.KEY_GBA_MODE_INT)) {
	case CarrierConfigManager.GBA_U:
	nafPrefix = THREE_GPP_BOOTSTRAPPING + "-uicc";
	break;
	case CarrierConfigManager.GBA_DIGEST:
	nafPrefix = THREE_GPP_BOOTSTRAPPING + "-digest";
	break;
	case CarrierConfigManager.GBA_ME:
	default:
	nafPrefix = THREE_GPP_BOOTSTRAPPING;
	}
	String newAuthority = nafPrefix + "@" + uploadUri.getAuthority();
	Uri nafUri = new Uri.Builder().scheme(uploadUri.getScheme())
	.encodedAuthority(newAuthority)
	.build();
	Log.i(TAG, "using NAF uri " + nafUri + " for GBA");
	return nafUri;
	}

	@VisibleForTesting
	static ScheduledExecutorService getExecutor() {
	return sExecutorService;
	}

	@VisibleForTesting
	void setCallLogProxy(CallLogProxy proxy) {
	mCallLogProxy = proxy;
	}
	}