src/com/android/phone/callcomposer/CallComposerPictureTransfer.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.net.ConnectivityManager;
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.net.NetworkRequest;
 import android.os.Build;
 import android.telephony.TelephonyManager;
 import android.util.Log;

 import androidx.annotation.NonNull;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.http.multipart.MultipartEntity;
 import com.android.internal.http.multipart.Part;

 import com.google.common.net.MediaType;

 import gov.nist.javax.sip.header.WWWAuthenticate;

 import org.xml.sax.InputSource;

 import java.io.BufferedReader;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.net.HttpURLConnection;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.charset.Charset;
 import java.time.Instant;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.Iterator;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;

 import javax.xml.namespace.NamespaceContext;
 import javax.xml.xpath.XPath;
 import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathExpressionException;
 import javax.xml.xpath.XPathFactory;

 public class CallComposerPictureTransfer {
     private static final String TAG = CallComposerPictureTransfer.class.getSimpleName();
     private static final int HTTP_TIMEOUT_MILLIS = 20000;
     private static final int DEFAULT_BACKOFF_MILLIS = 1000;
     private static final String THREE_GPP_GBA = "3gpp-gba";

     private static final int ERROR_UNKNOWN = 0;
     private static final int ERROR_HTTP_TIMEOUT = 1;
     private static final int ERROR_NO_AUTH_REQUIRED = 2;
     private static final int ERROR_FORBIDDEN = 3;

     public interface Factory {
         default CallComposerPictureTransfer create(Context context, int subscriptionId, String url,
                 ExecutorService executorService) {
             return new CallComposerPictureTransfer(context, subscriptionId, url, executorService);
         }
     }

     public interface PictureCallback {
         default void onError(@TelephonyManager.CallComposerException.CallComposerError int error) {}
         default void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {}
         default void onUploadSuccessful(String serverUrl) {}
         default void onDownloadSuccessful(ImageData data) {}
     }

     private static class NetworkAccessException extends RuntimeException {
         final int errorCode;

         NetworkAccessException(int errorCode) {
             this.errorCode = errorCode;
         }
     }

     private final Context mContext;
     private final int mSubscriptionId;
     private final String mUrl;
     private final ExecutorService mExecutorService;

     private PictureCallback mCallback;

     private CallComposerPictureTransfer(Context context, int subscriptionId, String url,
             ExecutorService executorService) {
         mContext = context;
         mSubscriptionId = subscriptionId;
         mExecutorService = executorService;
         mUrl = url;
     }

     @VisibleForTesting
     public void setCallback(PictureCallback callback) {
         mCallback = callback;
     }

     public void uploadPicture(ImageData image,
             GbaCredentialsSupplier credentialsSupplier) {
         CompletableFuture<Network> networkFuture = getNetworkForCallComposer();
         CompletableFuture<WWWAuthenticate> authorizationHeaderFuture = networkFuture
                 .thenApplyAsync((network) -> prepareInitialPost(network, mUrl), mExecutorService)
                 .thenComposeAsync(this::obtainAuthenticateHeader, mExecutorService)
                 .thenApplyAsync(DigestAuthUtils::parseAuthenticateHeader);
         CompletableFuture<GbaCredentials> credsFuture = authorizationHeaderFuture
                 .thenComposeAsync((header) ->
                         credentialsSupplier.getCredentials(header.getRealm(), mExecutorService),
                         mExecutorService);

         CompletableFuture<String> authorizationFuture =
                 authorizationHeaderFuture.thenCombineAsync(credsFuture,
                         (authHeader, credentials) ->
                                 DigestAuthUtils.generateAuthorizationHeader(
                                         authHeader, credentials, "POST", mUrl),
                         mExecutorService)
                         .whenCompleteAsync(
                                 (authorization, error) -> handleExceptionalCompletion(error),
                                 mExecutorService);

         CompletableFuture<String> networkUrlFuture =
                 networkFuture.thenCombineAsync(authorizationFuture,
                         (network, auth) -> sendActualImageUpload(network, auth, image),
                         mExecutorService);
         networkUrlFuture.thenAcceptAsync((result) -> {
             if (result != null) mCallback.onUploadSuccessful(result);
         }, mExecutorService).exceptionally((ex) -> {
             logException("Exception uploading image" , ex);
             return null;
         });
     }

     public void downloadPicture(GbaCredentialsSupplier credentialsSupplier) {
         CompletableFuture<Network> networkFuture = getNetworkForCallComposer();
         CompletableFuture<HttpURLConnection> getConnectionFuture =
                 networkFuture.thenApplyAsync((network) ->
                         prepareImageDownloadRequest(network, mUrl), mExecutorService);

         CompletableFuture<ImageData> immediatelyDownloadableImage = getConnectionFuture
                 .thenComposeAsync((conn) -> {
                     try {
                         if (conn.getResponseCode() != 200) {
                             return CompletableFuture.completedFuture(null);
                         }
                     } catch (IOException e) {
                         logException("IOException obtaining return code: ", e);
                         throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
                     }
                     return CompletableFuture.completedFuture(downloadImageFromConnection(conn));
                 }, mExecutorService);

         CompletableFuture<ImageData> authRequiredImage = getConnectionFuture
                 .thenComposeAsync((conn) -> {
                     try {
                         if (conn.getResponseCode() == 200) {
                             // handled by above case
                             return CompletableFuture.completedFuture(null);
                         }
                     } catch (IOException e) {
                         logException("IOException obtaining return code: ", e);
                         throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
                     }
                     CompletableFuture<WWWAuthenticate> authenticateHeaderFuture =
                             obtainAuthenticateHeader(conn)
                                     .thenApply(DigestAuthUtils::parseAuthenticateHeader);
                     CompletableFuture<GbaCredentials> credsFuture = authenticateHeaderFuture
                             .thenComposeAsync((header) ->
                                     credentialsSupplier.getCredentials(header.getRealm(),
                                             mExecutorService), mExecutorService);

                     CompletableFuture<String> authorizationFuture = authenticateHeaderFuture
                             .thenCombineAsync(credsFuture, (authHeader, credentials) ->
                                     DigestAuthUtils.generateAuthorizationHeader(
                                             authHeader, credentials, "GET", mUrl),
                                     mExecutorService)
                             .whenCompleteAsync((authorization, error) ->
                                     handleExceptionalCompletion(error), mExecutorService);

                     return networkFuture.thenCombineAsync(authorizationFuture,
                             this::downloadImageWithAuth, mExecutorService);
                 }, mExecutorService);

         CompletableFuture.allOf(immediatelyDownloadableImage, authRequiredImage).thenRun(() -> {
             ImageData fromImmediate = immediatelyDownloadableImage.getNow(null);
             ImageData fromAuth = authRequiredImage.getNow(null);
             // If both of these are null, that means an error happened somewhere in the chain.
             // in that case, the error has already been transmitted to the callback, so ignore it.
             if (fromAuth == null && fromImmediate == null) {
                 Log.w(TAG, "No result from download -- error happened sometime earlier");
             }
             if (fromAuth != null) mCallback.onDownloadSuccessful(fromAuth);
             mCallback.onDownloadSuccessful(fromImmediate);
         }).exceptionally((ex) -> {
             logException("Exception downloading image" , ex);
             return null;
         });
     }

     private CompletableFuture<Network> getNetworkForCallComposer() {
         ConnectivityManager connectivityManager =
                 mContext.getSystemService(ConnectivityManager.class);
         NetworkRequest pictureNetworkRequest = new NetworkRequest.Builder()
                 .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                 .build();
         CompletableFuture<Network> resultFuture = new CompletableFuture<>();
         connectivityManager.requestNetwork(pictureNetworkRequest,
                 new ConnectivityManager.NetworkCallback() {
                     @Override
                     public void onAvailable(@NonNull Network network) {
                         resultFuture.complete(network);
                     }
                 });
         return resultFuture;
     }

     private HttpURLConnection prepareInitialPost(Network network, String uploadUrl) {
         try {
             HttpURLConnection connection =
                     (HttpURLConnection) network.openConnection(new URL(uploadUrl));
             connection.setRequestMethod("POST");
             connection.setInstanceFollowRedirects(false);
             connection.setConnectTimeout(HTTP_TIMEOUT_MILLIS);
             connection.setReadTimeout(HTTP_TIMEOUT_MILLIS);
             connection.setRequestProperty("User-Agent", getUserAgent());
             return connection;
         } catch (MalformedURLException e) {
             Log.e(TAG, "Malformed URL: " + uploadUrl);
             throw new RuntimeException(e);
         } catch (IOException e) {
             logException("IOException opening network: ", e);
             throw new RuntimeException(e);
         }
     }

     private HttpURLConnection prepareImageDownloadRequest(Network network, String imageUrl) {
         try {
             HttpURLConnection connection =
                     (HttpURLConnection) network.openConnection(new URL(imageUrl));
             connection.setRequestMethod("GET");
             connection.setConnectTimeout(HTTP_TIMEOUT_MILLIS);
             connection.setReadTimeout(HTTP_TIMEOUT_MILLIS);
             connection.setRequestProperty("User-Agent", getUserAgent());
             return connection;
         } catch (MalformedURLException e) {
             Log.e(TAG, "Malformed URL: " + imageUrl);
             throw new RuntimeException(e);
         } catch (IOException e) {
             logException("IOException opening network: ", e);
             throw new RuntimeException(e);
         }
     }

     // Attempts to connect via the supplied connection, expecting a HTTP 401 in response. Throws
     // an IOException if the connection times out.
     // After the response is received, returns the WWW-Authenticate header in the following form:
     // "WWW-Authenticate:<method> <params>"
     private CompletableFuture<String> obtainAuthenticateHeader(
             HttpURLConnection connection) {
         return CompletableFuture.supplyAsync(() -> {
             int responseCode;
             try {
                 responseCode = connection.getResponseCode();
             } catch (IOException e) {
                 logException("IOException obtaining auth header: ", e);
                 throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
             }
             if (responseCode == 204) {
                 throw new NetworkAccessException(ERROR_NO_AUTH_REQUIRED);
             } else if (responseCode == 403) {
                 throw new NetworkAccessException(ERROR_FORBIDDEN);
             } else if (responseCode != 401) {
                 Log.w(TAG, "Received unexpected response in auth request, code= "
                         + responseCode);
                 throw new NetworkAccessException(ERROR_UNKNOWN);
             }

             return connection.getHeaderField(DigestAuthUtils.WWW_AUTHENTICATE);
         }, mExecutorService);
     }

     private ImageData downloadImageWithAuth(Network network, String authorization) {
         HttpURLConnection connection = prepareImageDownloadRequest(network, mUrl);
         connection.addRequestProperty("Authorization", authorization);
         return downloadImageFromConnection(connection);
     }

     private ImageData downloadImageFromConnection(HttpURLConnection conn) {
         try {
             if (conn.getResponseCode() != 200) {
                 Log.w(TAG, "Got response code " + conn.getResponseCode() + " when trying"
                         + " to download image");
                 if (conn.getResponseCode() == 401) {
                     Log.i(TAG, "Got 401 even with auth -- key refresh needed?");
                     mCallback.onRetryNeeded(true, 0);
                 }
                 return null;
             }
         } catch (IOException e) {
             logException("IOException obtaining return code: ", e);
             throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
         }

         String contentType = conn.getContentType();
         ByteArrayOutputStream imageDataOut = new ByteArrayOutputStream();
         byte[] buffer = new byte[4096];
         int numRead;
         try {
             InputStream is = conn.getInputStream();
             while (true) {
                 numRead = is.read(buffer);
                 if (numRead < 0) break;
                 imageDataOut.write(buffer, 0, numRead);
             }
         } catch (IOException e) {
             logException("IOException reading from image body: ", e);
             return null;
         }

         return new ImageData(imageDataOut.toByteArray(), contentType, null);
     }

     private void handleExceptionalCompletion(Throwable error) {
         if (error != null) {
             if (error.getCause() instanceof NetworkAccessException) {
                 int code = ((NetworkAccessException) error.getCause()).errorCode;
                 if (code == ERROR_UNKNOWN || code == ERROR_HTTP_TIMEOUT) {
                     scheduleRetry();
                 } else {
                     int failureCode;
                     if (code == ERROR_FORBIDDEN) {
                         failureCode = TelephonyManager.CallComposerException
                                 .ERROR_AUTHENTICATION_FAILED;
                     } else {
                         failureCode = TelephonyManager.CallComposerException
                                 .ERROR_UNKNOWN;
                     }
                     deliverFailure(failureCode);
                 }
             } else {
                 deliverFailure(TelephonyManager.CallComposerException.ERROR_UNKNOWN);
             }
         }
     }

     private void scheduleRetry() {
         mCallback.onRetryNeeded(false, DEFAULT_BACKOFF_MILLIS);
     }

     private void deliverFailure(int code) {
         mCallback.onError(code);
     }

     private static Part makeUploadPart(String name, String contentType, String filename,
             byte[] data) {
         return new Part() {
             @Override
             public String getName() {
                 return name;
             }

             @Override
             public String getContentType() {
                 return contentType;
             }

             @Override
             public String getCharSet() {
                 return null;
             }

             @Override
             public String getTransferEncoding() {
                 return null;
             }

             @Override
             public void sendDispositionHeader(OutputStream out) throws IOException {
                 super.sendDispositionHeader(out);
                 if (filename != null) {
                     String fileNameSuffix = "; filename=\"" + filename + "\"";
                     out.write(fileNameSuffix.getBytes());
                 }
             }

             @Override
             protected void sendData(OutputStream out) throws IOException {
                 out.write(data);
             }

             @Override
             protected long lengthOfData() throws IOException {
                 return data.length;
             }
         };
     }

     private String sendActualImageUpload(Network network, String authHeader, ImageData image) {
         Part transactionIdPart = makeUploadPart("tid", "text/plain",
                 null, image.getId().getBytes());
         Part imageDataPart = makeUploadPart("File", image.getMimeType(),
                 image.getId(), image.getImageBytes());

         MultipartEntity multipartEntity =
                 new MultipartEntity(new Part[] {transactionIdPart, imageDataPart});

         HttpURLConnection connection = prepareInitialPost(network, mUrl);
         connection.setDoOutput(true);
         connection.addRequestProperty("Authorization", authHeader);
         connection.addRequestProperty("Content-Length",
                 String.valueOf(multipartEntity.getContentLength()));
         connection.addRequestProperty("Content-Type", multipartEntity.getContentType().getValue());
         connection.addRequestProperty("Accept-Encoding", "*");

         try (OutputStream requestBodyOut = connection.getOutputStream()) {
             multipartEntity.writeTo(requestBodyOut);
         } catch (IOException e) {
             logException("IOException making request to upload image: ", e);
             throw new RuntimeException(e);
         }

         try {
             int response = connection.getResponseCode();
             Log.i(TAG, "Received response code: " + response
                     + ", message=" + connection.getResponseMessage());
             if (response == 401 || response == 403) {
                 deliverFailure(TelephonyManager.CallComposerException.ERROR_AUTHENTICATION_FAILED);
                 return null;
             }
             if (response == 503) {
                 // TODO: implement parsing of retry-after and schedule a retry with that time
                 scheduleRetry();
                 return null;
             }
             if (response != 200) {
                 scheduleRetry();
                 return null;
             }
             String responseBody = readResponseBody(connection);
             String parsedUrl = parseImageUploadResponseXmlForUrl(responseBody);
             Log.i(TAG, "Parsed URL as upload result: " + parsedUrl);
             return parsedUrl;
         } catch (IOException e) {
             logException("IOException getting response to image upload: ", e);
             deliverFailure(TelephonyManager.CallComposerException.ERROR_UNKNOWN);
             return null;
         }
     }

     private static String parseImageUploadResponseXmlForUrl(String xmlData) {
         NamespaceContext ns = new NamespaceContext() {
             public String getNamespaceURI(String prefix) {
                 return "urn:gsma:params:xml:ns:rcs:rcs:fthttp";
             }

             public String getPrefix(String uri) {
                 throw new UnsupportedOperationException();
             }

             public Iterator getPrefixes(String uri) {
                 throw new UnsupportedOperationException();
             }
         };

         XPath xPath = XPathFactory.newInstance().newXPath();
         xPath.setNamespaceContext(ns);
         StringReader reader = new StringReader(xmlData);
         try {
             return (String) xPath.evaluate("/a:file/a:file-info[@type='file']/a:data/@url",
                     new InputSource(reader), XPathConstants.STRING);
         } catch (XPathExpressionException e) {
             logException("Error parsing response XML:", e);
             return null;
         }
     }

     private static String readResponseBody(HttpURLConnection connection) {
         Charset charset = MediaType.parse(connection.getContentType())
                 .charset().or(Charset.defaultCharset());
         StringBuilder sb = new StringBuilder();
         try (InputStream inputStream = connection.getInputStream()) {
             String outLine;
             BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, charset));
             while ((outLine = reader.readLine()) != null) {
                 sb.append(outLine);
             }
         } catch (IOException e) {
             logException("IOException reading request body: ", e);
             return null;
         }
         return sb.toString();
     }

     private String getUserAgent() {
         String carrierName = mContext.getSystemService(TelephonyManager.class)
                 .createForSubscriptionId(mSubscriptionId)
                 .getSimOperatorName();
         String buildId = Build.ID;
         String buildDate = DateTimeFormatter.ofPattern("yyyy-MM-dd")
                 .withZone(ZoneId.systemDefault())
                 .format(Instant.ofEpochMilli(Build.TIME));
         String buildVersion = Build.VERSION.RELEASE_OR_CODENAME;
         String deviceName = Build.DEVICE;
         return String.format("%s %s %s %s %s %s %s",
                 carrierName, buildId, buildDate, "Android", buildVersion,
                 deviceName, THREE_GPP_GBA);

     }

     private static void logException(String message, Throwable e) {
         StringWriter log = new StringWriter();
         log.append(message);
         log.append(":\n");
         log.append(e.getMessage());
         PrintWriter pw = new PrintWriter(log);
         e.printStackTrace(pw);
         Log.e(TAG, log.toString());
     }
 }
	/*
	* 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.net.ConnectivityManager;
	import android.net.Network;
	import android.net.NetworkCapabilities;
	import android.net.NetworkRequest;
	import android.os.Build;
	import android.telephony.TelephonyManager;
	import android.util.Log;

	import androidx.annotation.NonNull;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.http.multipart.MultipartEntity;
	import com.android.internal.http.multipart.Part;

	import com.google.common.net.MediaType;

	import gov.nist.javax.sip.header.WWWAuthenticate;

	import org.xml.sax.InputSource;

	import java.io.BufferedReader;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.OutputStream;
	import java.io.PrintWriter;
	import java.io.StringReader;
	import java.io.StringWriter;
	import java.net.HttpURLConnection;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.nio.charset.Charset;
	import java.time.Instant;
	import java.time.ZoneId;
	import java.time.format.DateTimeFormatter;
	import java.util.Iterator;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.ExecutorService;

	import javax.xml.namespace.NamespaceContext;
	import javax.xml.xpath.XPath;
	import javax.xml.xpath.XPathConstants;
	import javax.xml.xpath.XPathExpressionException;
	import javax.xml.xpath.XPathFactory;

	public class CallComposerPictureTransfer {
	private static final String TAG = CallComposerPictureTransfer.class.getSimpleName();
	private static final int HTTP_TIMEOUT_MILLIS = 20000;
	private static final int DEFAULT_BACKOFF_MILLIS = 1000;
	private static final String THREE_GPP_GBA = "3gpp-gba";

	private static final int ERROR_UNKNOWN = 0;
	private static final int ERROR_HTTP_TIMEOUT = 1;
	private static final int ERROR_NO_AUTH_REQUIRED = 2;
	private static final int ERROR_FORBIDDEN = 3;

	public interface Factory {
	default CallComposerPictureTransfer create(Context context, int subscriptionId, String url,
	ExecutorService executorService) {
	return new CallComposerPictureTransfer(context, subscriptionId, url, executorService);
	}
	}

	public interface PictureCallback {
	default void onError(@TelephonyManager.CallComposerException.CallComposerError int error) {}
	default void onRetryNeeded(boolean credentialRefresh, long backoffMillis) {}
	default void onUploadSuccessful(String serverUrl) {}
	default void onDownloadSuccessful(ImageData data) {}
	}

	private static class NetworkAccessException extends RuntimeException {
	final int errorCode;

	NetworkAccessException(int errorCode) {
	this.errorCode = errorCode;
	}
	}

	private final Context mContext;
	private final int mSubscriptionId;
	private final String mUrl;
	private final ExecutorService mExecutorService;

	private PictureCallback mCallback;

	private CallComposerPictureTransfer(Context context, int subscriptionId, String url,
	ExecutorService executorService) {
	mContext = context;
	mSubscriptionId = subscriptionId;
	mExecutorService = executorService;
	mUrl = url;
	}

	@VisibleForTesting
	public void setCallback(PictureCallback callback) {
	mCallback = callback;
	}

	public void uploadPicture(ImageData image,
	GbaCredentialsSupplier credentialsSupplier) {
	CompletableFuture<Network> networkFuture = getNetworkForCallComposer();
	CompletableFuture<WWWAuthenticate> authorizationHeaderFuture = networkFuture
	.thenApplyAsync((network) -> prepareInitialPost(network, mUrl), mExecutorService)
	.thenComposeAsync(this::obtainAuthenticateHeader, mExecutorService)
	.thenApplyAsync(DigestAuthUtils::parseAuthenticateHeader);
	CompletableFuture<GbaCredentials> credsFuture = authorizationHeaderFuture
	.thenComposeAsync((header) ->
	credentialsSupplier.getCredentials(header.getRealm(), mExecutorService),
	mExecutorService);

	CompletableFuture<String> authorizationFuture =
	authorizationHeaderFuture.thenCombineAsync(credsFuture,
	(authHeader, credentials) ->
	DigestAuthUtils.generateAuthorizationHeader(
	authHeader, credentials, "POST", mUrl),
	mExecutorService)
	.whenCompleteAsync(
	(authorization, error) -> handleExceptionalCompletion(error),
	mExecutorService);

	CompletableFuture<String> networkUrlFuture =
	networkFuture.thenCombineAsync(authorizationFuture,
	(network, auth) -> sendActualImageUpload(network, auth, image),
	mExecutorService);
	networkUrlFuture.thenAcceptAsync((result) -> {
	if (result != null) mCallback.onUploadSuccessful(result);
	}, mExecutorService).exceptionally((ex) -> {
	logException("Exception uploading image" , ex);
	return null;
	});
	}

	public void downloadPicture(GbaCredentialsSupplier credentialsSupplier) {
	CompletableFuture<Network> networkFuture = getNetworkForCallComposer();
	CompletableFuture<HttpURLConnection> getConnectionFuture =
	networkFuture.thenApplyAsync((network) ->
	prepareImageDownloadRequest(network, mUrl), mExecutorService);

	CompletableFuture<ImageData> immediatelyDownloadableImage = getConnectionFuture
	.thenComposeAsync((conn) -> {
	try {
	if (conn.getResponseCode() != 200) {
	return CompletableFuture.completedFuture(null);
	}
	} catch (IOException e) {
	logException("IOException obtaining return code: ", e);
	throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
	}
	return CompletableFuture.completedFuture(downloadImageFromConnection(conn));
	}, mExecutorService);

	CompletableFuture<ImageData> authRequiredImage = getConnectionFuture
	.thenComposeAsync((conn) -> {
	try {
	if (conn.getResponseCode() == 200) {
	// handled by above case
	return CompletableFuture.completedFuture(null);
	}
	} catch (IOException e) {
	logException("IOException obtaining return code: ", e);
	throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
	}
	CompletableFuture<WWWAuthenticate> authenticateHeaderFuture =
	obtainAuthenticateHeader(conn)
	.thenApply(DigestAuthUtils::parseAuthenticateHeader);
	CompletableFuture<GbaCredentials> credsFuture = authenticateHeaderFuture
	.thenComposeAsync((header) ->
	credentialsSupplier.getCredentials(header.getRealm(),
	mExecutorService), mExecutorService);

	CompletableFuture<String> authorizationFuture = authenticateHeaderFuture
	.thenCombineAsync(credsFuture, (authHeader, credentials) ->
	DigestAuthUtils.generateAuthorizationHeader(
	authHeader, credentials, "GET", mUrl),
	mExecutorService)
	.whenCompleteAsync((authorization, error) ->
	handleExceptionalCompletion(error), mExecutorService);

	return networkFuture.thenCombineAsync(authorizationFuture,
	this::downloadImageWithAuth, mExecutorService);
	}, mExecutorService);

	CompletableFuture.allOf(immediatelyDownloadableImage, authRequiredImage).thenRun(() -> {
	ImageData fromImmediate = immediatelyDownloadableImage.getNow(null);
	ImageData fromAuth = authRequiredImage.getNow(null);
	// If both of these are null, that means an error happened somewhere in the chain.
	// in that case, the error has already been transmitted to the callback, so ignore it.
	if (fromAuth == null && fromImmediate == null) {
	Log.w(TAG, "No result from download -- error happened sometime earlier");
	}
	if (fromAuth != null) mCallback.onDownloadSuccessful(fromAuth);
	mCallback.onDownloadSuccessful(fromImmediate);
	}).exceptionally((ex) -> {
	logException("Exception downloading image" , ex);
	return null;
	});
	}

	private CompletableFuture<Network> getNetworkForCallComposer() {
	ConnectivityManager connectivityManager =
	mContext.getSystemService(ConnectivityManager.class);
	NetworkRequest pictureNetworkRequest = new NetworkRequest.Builder()
	.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
	.build();
	CompletableFuture<Network> resultFuture = new CompletableFuture<>();
	connectivityManager.requestNetwork(pictureNetworkRequest,
	new ConnectivityManager.NetworkCallback() {
	@Override
	public void onAvailable(@NonNull Network network) {
	resultFuture.complete(network);
	}
	});
	return resultFuture;
	}

	private HttpURLConnection prepareInitialPost(Network network, String uploadUrl) {
	try {
	HttpURLConnection connection =
	(HttpURLConnection) network.openConnection(new URL(uploadUrl));
	connection.setRequestMethod("POST");
	connection.setInstanceFollowRedirects(false);
	connection.setConnectTimeout(HTTP_TIMEOUT_MILLIS);
	connection.setReadTimeout(HTTP_TIMEOUT_MILLIS);
	connection.setRequestProperty("User-Agent", getUserAgent());
	return connection;
	} catch (MalformedURLException e) {
	Log.e(TAG, "Malformed URL: " + uploadUrl);
	throw new RuntimeException(e);
	} catch (IOException e) {
	logException("IOException opening network: ", e);
	throw new RuntimeException(e);
	}
	}

	private HttpURLConnection prepareImageDownloadRequest(Network network, String imageUrl) {
	try {
	HttpURLConnection connection =
	(HttpURLConnection) network.openConnection(new URL(imageUrl));
	connection.setRequestMethod("GET");
	connection.setConnectTimeout(HTTP_TIMEOUT_MILLIS);
	connection.setReadTimeout(HTTP_TIMEOUT_MILLIS);
	connection.setRequestProperty("User-Agent", getUserAgent());
	return connection;
	} catch (MalformedURLException e) {
	Log.e(TAG, "Malformed URL: " + imageUrl);
	throw new RuntimeException(e);
	} catch (IOException e) {
	logException("IOException opening network: ", e);
	throw new RuntimeException(e);
	}
	}

	// Attempts to connect via the supplied connection, expecting a HTTP 401 in response. Throws
	// an IOException if the connection times out.
	// After the response is received, returns the WWW-Authenticate header in the following form:
	// "WWW-Authenticate:<method> <params>"
	private CompletableFuture<String> obtainAuthenticateHeader(
	HttpURLConnection connection) {
	return CompletableFuture.supplyAsync(() -> {
	int responseCode;
	try {
	responseCode = connection.getResponseCode();
	} catch (IOException e) {
	logException("IOException obtaining auth header: ", e);
	throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
	}
	if (responseCode == 204) {
	throw new NetworkAccessException(ERROR_NO_AUTH_REQUIRED);
	} else if (responseCode == 403) {
	throw new NetworkAccessException(ERROR_FORBIDDEN);
	} else if (responseCode != 401) {
	Log.w(TAG, "Received unexpected response in auth request, code= "
	+ responseCode);
	throw new NetworkAccessException(ERROR_UNKNOWN);
	}

	return connection.getHeaderField(DigestAuthUtils.WWW_AUTHENTICATE);
	}, mExecutorService);
	}

	private ImageData downloadImageWithAuth(Network network, String authorization) {
	HttpURLConnection connection = prepareImageDownloadRequest(network, mUrl);
	connection.addRequestProperty("Authorization", authorization);
	return downloadImageFromConnection(connection);
	}

	private ImageData downloadImageFromConnection(HttpURLConnection conn) {
	try {
	if (conn.getResponseCode() != 200) {
	Log.w(TAG, "Got response code " + conn.getResponseCode() + " when trying"
	+ " to download image");
	if (conn.getResponseCode() == 401) {
	Log.i(TAG, "Got 401 even with auth -- key refresh needed?");
	mCallback.onRetryNeeded(true, 0);
	}
	return null;
	}
	} catch (IOException e) {
	logException("IOException obtaining return code: ", e);
	throw new NetworkAccessException(ERROR_HTTP_TIMEOUT);
	}

	String contentType = conn.getContentType();
	ByteArrayOutputStream imageDataOut = new ByteArrayOutputStream();
	byte[] buffer = new byte[4096];
	int numRead;
	try {
	InputStream is = conn.getInputStream();
	while (true) {
	numRead = is.read(buffer);
	if (numRead < 0) break;
	imageDataOut.write(buffer, 0, numRead);
	}
	} catch (IOException e) {
	logException("IOException reading from image body: ", e);
	return null;
	}

	return new ImageData(imageDataOut.toByteArray(), contentType, null);
	}

	private void handleExceptionalCompletion(Throwable error) {
	if (error != null) {
	if (error.getCause() instanceof NetworkAccessException) {
	int code = ((NetworkAccessException) error.getCause()).errorCode;
	if (code == ERROR_UNKNOWN \|\| code == ERROR_HTTP_TIMEOUT) {
	scheduleRetry();
	} else {
	int failureCode;
	if (code == ERROR_FORBIDDEN) {
	failureCode = TelephonyManager.CallComposerException
	.ERROR_AUTHENTICATION_FAILED;
	} else {
	failureCode = TelephonyManager.CallComposerException
	.ERROR_UNKNOWN;
	}
	deliverFailure(failureCode);
	}
	} else {
	deliverFailure(TelephonyManager.CallComposerException.ERROR_UNKNOWN);
	}
	}
	}

	private void scheduleRetry() {
	mCallback.onRetryNeeded(false, DEFAULT_BACKOFF_MILLIS);
	}

	private void deliverFailure(int code) {
	mCallback.onError(code);
	}

	private static Part makeUploadPart(String name, String contentType, String filename,
	byte[] data) {
	return new Part() {
	@Override
	public String getName() {
	return name;
	}

	@Override
	public String getContentType() {
	return contentType;
	}

	@Override
	public String getCharSet() {
	return null;
	}

	@Override
	public String getTransferEncoding() {
	return null;
	}

	@Override
	public void sendDispositionHeader(OutputStream out) throws IOException {
	super.sendDispositionHeader(out);
	if (filename != null) {
	String fileNameSuffix = "; filename=\"" + filename + "\"";
	out.write(fileNameSuffix.getBytes());
	}
	}

	@Override
	protected void sendData(OutputStream out) throws IOException {
	out.write(data);
	}

	@Override
	protected long lengthOfData() throws IOException {
	return data.length;
	}
	};
	}

	private String sendActualImageUpload(Network network, String authHeader, ImageData image) {
	Part transactionIdPart = makeUploadPart("tid", "text/plain",
	null, image.getId().getBytes());
	Part imageDataPart = makeUploadPart("File", image.getMimeType(),
	image.getId(), image.getImageBytes());

	MultipartEntity multipartEntity =
	new MultipartEntity(new Part[] {transactionIdPart, imageDataPart});

	HttpURLConnection connection = prepareInitialPost(network, mUrl);
	connection.setDoOutput(true);
	connection.addRequestProperty("Authorization", authHeader);
	connection.addRequestProperty("Content-Length",
	String.valueOf(multipartEntity.getContentLength()));
	connection.addRequestProperty("Content-Type", multipartEntity.getContentType().getValue());
	connection.addRequestProperty("Accept-Encoding", "*");

	try (OutputStream requestBodyOut = connection.getOutputStream()) {
	multipartEntity.writeTo(requestBodyOut);
	} catch (IOException e) {
	logException("IOException making request to upload image: ", e);
	throw new RuntimeException(e);
	}

	try {
	int response = connection.getResponseCode();
	Log.i(TAG, "Received response code: " + response
	+ ", message=" + connection.getResponseMessage());
	if (response == 401 \|\| response == 403) {
	deliverFailure(TelephonyManager.CallComposerException.ERROR_AUTHENTICATION_FAILED);
	return null;
	}
	if (response == 503) {
	// TODO: implement parsing of retry-after and schedule a retry with that time
	scheduleRetry();
	return null;
	}
	if (response != 200) {
	scheduleRetry();
	return null;
	}
	String responseBody = readResponseBody(connection);
	String parsedUrl = parseImageUploadResponseXmlForUrl(responseBody);
	Log.i(TAG, "Parsed URL as upload result: " + parsedUrl);
	return parsedUrl;
	} catch (IOException e) {
	logException("IOException getting response to image upload: ", e);
	deliverFailure(TelephonyManager.CallComposerException.ERROR_UNKNOWN);
	return null;
	}
	}

	private static String parseImageUploadResponseXmlForUrl(String xmlData) {
	NamespaceContext ns = new NamespaceContext() {
	public String getNamespaceURI(String prefix) {
	return "urn:gsma:params:xml:ns:rcs:rcs:fthttp";
	}

	public String getPrefix(String uri) {
	throw new UnsupportedOperationException();
	}

	public Iterator getPrefixes(String uri) {
	throw new UnsupportedOperationException();
	}
	};

	XPath xPath = XPathFactory.newInstance().newXPath();
	xPath.setNamespaceContext(ns);
	StringReader reader = new StringReader(xmlData);
	try {
	return (String) xPath.evaluate("/a:file/a:file-info[@type='file']/a:data/@url",
	new InputSource(reader), XPathConstants.STRING);
	} catch (XPathExpressionException e) {
	logException("Error parsing response XML:", e);
	return null;
	}
	}

	private static String readResponseBody(HttpURLConnection connection) {
	Charset charset = MediaType.parse(connection.getContentType())
	.charset().or(Charset.defaultCharset());
	StringBuilder sb = new StringBuilder();
	try (InputStream inputStream = connection.getInputStream()) {
	String outLine;
	BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, charset));
	while ((outLine = reader.readLine()) != null) {
	sb.append(outLine);
	}
	} catch (IOException e) {
	logException("IOException reading request body: ", e);
	return null;
	}
	return sb.toString();
	}

	private String getUserAgent() {
	String carrierName = mContext.getSystemService(TelephonyManager.class)
	.createForSubscriptionId(mSubscriptionId)
	.getSimOperatorName();
	String buildId = Build.ID;
	String buildDate = DateTimeFormatter.ofPattern("yyyy-MM-dd")
	.withZone(ZoneId.systemDefault())
	.format(Instant.ofEpochMilli(Build.TIME));
	String buildVersion = Build.VERSION.RELEASE_OR_CODENAME;
	String deviceName = Build.DEVICE;
	return String.format("%s %s %s %s %s %s %s",
	carrierName, buildId, buildDate, "Android", buildVersion,
	deviceName, THREE_GPP_GBA);

	}

	private static void logException(String message, Throwable e) {
	StringWriter log = new StringWriter();
	log.append(message);
	log.append(":\n");
	log.append(e.getMessage());
	PrintWriter pw = new PrintWriter(log);
	e.printStackTrace(pw);
	Log.e(TAG, log.toString());
	}
	}