mms/service/MmsRequest.java

/*
 * Copyright (C) 2014 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.mms.service;

import android.annotation.NonNull;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.service.carrier.CarrierMessagingService;
import android.service.carrier.CarrierMessagingServiceWrapper.CarrierMessagingCallback;
import android.telephony.AnomalyReporter;
import android.telephony.CarrierConfigManager;
import android.telephony.PreciseDataConnectionState;
import android.telephony.ServiceState;
import android.telephony.SmsManager;
import android.telephony.TelephonyCallback;
import android.telephony.TelephonyManager;
import android.telephony.data.ApnSetting;
import android.telephony.ims.ImsMmTelManager;
import android.telephony.ims.feature.MmTelFeature;
import android.telephony.ims.stub.ImsRegistrationImplBase;
import android.util.SparseArray;

import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.flags.Flags;
import com.android.mms.service.exception.ApnException;
import com.android.mms.service.exception.MmsHttpException;
import com.android.mms.service.exception.MmsNetworkException;
import com.android.mms.service.metrics.MmsStats;

import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Base class for MMS requests. This has the common logic of sending/downloading MMS.
 */
public abstract class MmsRequest {
    private static final int RETRY_TIMES = 3;
    // Signal level threshold for both wifi and cellular
    private static final int SIGNAL_LEVEL_THRESHOLD = 2;
    public static final String EXTRA_LAST_CONNECTION_FAILURE_CAUSE_CODE
            = "android.telephony.extra.LAST_CONNECTION_FAILURE_CAUSE_CODE";
    public static final String EXTRA_HANDLED_BY_CARRIER_APP
            = "android.telephony.extra.HANDLED_BY_CARRIER_APP";

    /**
     * Interface for certain functionalities from MmsService
     */
    public static interface RequestManager {
        /**
         * Enqueue an MMS request
         *
         * @param request the request to enqueue
         */
        public void addSimRequest(MmsRequest request);

        /*
         * @return Whether to auto persist received MMS
         */
        public boolean getAutoPersistingPref();

        /**
         * Read pdu (up to maxSize bytes) from supplied content uri
         * @param contentUri content uri from which to read
         * @param maxSize maximum number of bytes to read
         * @param callingUser user id of the calling app
         * @return read pdu (else null in case of error or too big)
         */
        public byte[] readPduFromContentUri(final Uri contentUri, final int maxSize,
                int callingUser);

        /**
         * Write pdu to supplied content uri
         * @param contentUri content uri to which bytes should be written
         * @param pdu pdu bytes to write
         * @return true in case of success (else false)
         */
        public boolean writePduToContentUri(final Uri contentUri, final byte[] pdu);
    }

    // The reference to the pending requests manager (i.e. the MmsService)
    protected RequestManager mRequestManager;
    // The SIM id
    protected int mSubId;
    // The creator app
    protected String mCreator;
    // MMS config
    protected Bundle mMmsConfig;
    // Context used to get TelephonyManager.
    protected Context mContext;
    protected long mMessageId;
    protected int mLastConnectionFailure;
    private MmsStats mMmsStats;
    private int result;
    private int httpStatusCode;
    protected TelephonyManager mTelephonyManager;
    @VisibleForTesting
    public int SATELLITE_MMS_SIZE_LIMIT = 3 * 1024;    // TODO - read from a carrier config setting

    protected enum MmsRequestState {
        Unknown,
        Created,
        PrepareForHttpRequest,
        AcquiringNetwork,
        LoadingApn,
        DoingHttp,
        Success,
        Failure
    };
    protected MmsRequestState currentState = MmsRequestState.Unknown;

    class MonitorTelephonyCallback extends TelephonyCallback implements
            TelephonyCallback.PreciseDataConnectionStateListener {

        /** The lock to update mNetworkIdToApn. */
        private final Object mLock = new Object();
        /**
         * Track the network agent Id to APN. Usually we have at most 2 networks that are capable of
         * MMS at the same time (terrestrial and satellite)
         */
        @GuardedBy("mLock")
        private final SparseArray<ApnSetting> mNetworkIdToApn = new SparseArray<>(2);
        @Override
        public void onPreciseDataConnectionStateChanged(
                @NonNull PreciseDataConnectionState connectionState) {
            ApnSetting apnSetting = connectionState.getApnSetting();
            if (apnSetting != null) {
                // Only track networks that are capable of MMS.
                if ((apnSetting.getApnTypeBitmask() & ApnSetting.TYPE_MMS) != 0) {
                    LogUtil.d("onPreciseDataConnectionStateChanged: " + connectionState);
                    mLastConnectionFailure = connectionState.getLastCauseCode();
                    if (Flags.mmsGetApnFromPdsc()) {
                        synchronized (mLock) {
                            mNetworkIdToApn.put(connectionState.getNetId(), apnSetting);
                        }
                    }
                }
            }
        }
    }

    public MmsRequest(RequestManager requestManager, int subId, String creator,
            Bundle mmsConfig, Context context, long messageId, MmsStats mmsStats,
            TelephonyManager telephonyManager) {
        currentState = MmsRequestState.Created;
        mRequestManager = requestManager;
        mSubId = subId;
        mCreator = creator;
        mMmsConfig = mmsConfig;
        mContext = context;
        mMessageId = messageId;
        mMmsStats = mmsStats;
        mTelephonyManager = telephonyManager;
    }

    public int getSubId() {
        return mSubId;
    }

    /**
     * Execute the request
     *
     * @param context The context
     * @param networkManager The network manager to use
     */
    public void execute(Context context, MmsNetworkManager networkManager) {
        final String requestId = this.getRequestId();
        LogUtil.i(requestId, "Executing...");
        result = SmsManager.MMS_ERROR_UNSPECIFIED;
        httpStatusCode = 0;
        byte[] response = null;
        int retryId = 0;
        currentState = MmsRequestState.PrepareForHttpRequest;

        if (!prepareForHttpRequest()) { // Prepare request, like reading pdu data from user
            LogUtil.e(requestId, "Failed to prepare for request");
            result = SmsManager.MMS_ERROR_IO_ERROR;
        } else { // Execute
            long retryDelaySecs = 2;
            // Try multiple times of MMS HTTP request, depending on the error.
            for (retryId = 0; retryId < RETRY_TIMES; retryId++) {
                httpStatusCode = 0; // Clear for retry.
                MonitorTelephonyCallback connectionStateCallback = new MonitorTelephonyCallback();
                try {
                    listenToDataConnectionState(connectionStateCallback);
                    currentState = MmsRequestState.AcquiringNetwork;
                    int networkId = networkManager.acquireNetwork(requestId);
                    currentState = MmsRequestState.LoadingApn;
                    ApnSettings apn = null;
                    ApnSetting networkApn = null;
                    if (Flags.mmsGetApnFromPdsc()) {
                        synchronized (connectionStateCallback.mLock) {
                            networkApn = connectionStateCallback.mNetworkIdToApn.get(networkId);
                        }
                        if (networkApn != null) {
                            apn = ApnSettings.getApnSettingsFromNetworkApn(networkApn);
                        }
                    }
                    if (apn == null) {
                        final String apnName = networkManager.getApnName();
                        LogUtil.d(requestId, "APN name is " + apnName);
                        try {
                            apn = ApnSettings.load(context, apnName, mSubId, requestId);
                        } catch (ApnException e) {
                            // If no APN could be found, fall back to trying without the APN name
                            if (apnName == null) {
                                // If the APN name was already null then don't need to retry
                                throw (e);
                            }
                            LogUtil.i(requestId, "No match with APN name: "
                                    + apnName + ", try with no name");
                            apn = ApnSettings.load(context, null, mSubId, requestId);
                        }
                    }

                    if (Flags.mmsGetApnFromPdsc() && networkApn == null && apn != null) {
                        reportAnomaly("Can't find MMS APN in mms network",
                                UUID.fromString("2bdda74d-3cf4-44ad-a87f-24c961212a6f"));
                    }

                    LogUtil.d(requestId, "Using APN " + apn);
                    if (networkManager.isSatelliteTransport()
                            && !canTransferPayloadOnCurrentNetwork()) {
                        LogUtil.e(requestId, "PDU too large for satellite");
                        result = SmsManager.MMS_ERROR_TOO_LARGE_FOR_TRANSPORT;
                        break;
                    }
                    currentState = MmsRequestState.DoingHttp;
                    response = doHttp(context, networkManager, apn);
                    result = Activity.RESULT_OK;
                    // Success
                    break;
                } catch (ApnException e) {
                    LogUtil.e(requestId, "APN failure", e);
                    result = SmsManager.MMS_ERROR_INVALID_APN;
                    break;
                } catch (MmsNetworkException e) {
                    LogUtil.e(requestId, "MMS network acquiring failure", e);
                    result = SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS;
                    break;
                } catch (MmsHttpException e) {
                    LogUtil.e(requestId, "HTTP or network I/O failure", e);
                    result = SmsManager.MMS_ERROR_HTTP_FAILURE;
                    httpStatusCode = e.getStatusCode();
                    // Retry
                } catch (Exception e) {
                    LogUtil.e(requestId, "Unexpected failure", e);
                    result = SmsManager.MMS_ERROR_UNSPECIFIED;
                    break;
                } finally {
                    // Release the MMS network immediately except successful DownloadRequest.
                    networkManager.releaseNetwork(requestId,
                            this instanceof DownloadRequest
                                    && result == Activity.RESULT_OK);
                    stopListeningToDataConnectionState(connectionStateCallback);
                }

                if (result != Activity.RESULT_CANCELED) {
                    try { // Cool down retry if the previous attempt wasn't voluntarily cancelled.
                        new CountDownLatch(1).await(retryDelaySecs, TimeUnit.SECONDS);
                    } catch (InterruptedException e) { }
                    // Double the cool down time if the next try fails again.
                    retryDelaySecs <<= 1;
                }
            }
        }
        processResult(context, result, response, httpStatusCode, /* handledByCarrierApp= */ false,
                retryId);
    }

    private void listenToDataConnectionState(MonitorTelephonyCallback connectionStateCallback) {
        final TelephonyManager telephonyManager = mContext.getSystemService(
                TelephonyManager.class).createForSubscriptionId(mSubId);
        telephonyManager.registerTelephonyCallback(r -> r.run(), connectionStateCallback);
    }

    private void stopListeningToDataConnectionState(
            MonitorTelephonyCallback connectionStateCallback) {
        final TelephonyManager telephonyManager = mContext.getSystemService(
                TelephonyManager.class).createForSubscriptionId(mSubId);
        telephonyManager.unregisterTelephonyCallback(connectionStateCallback);
    }

    /**
     * Process the result of the completed request, including updating the message status
     * in database and sending back the result via pending intents.
     * @param context The context
     * @param result The result code of execution
     * @param response The response body
     * @param httpStatusCode The optional http status code in case of http failure
     * @param handledByCarrierApp True if the sending/downloading was handled by a carrier app
     *                            rather than MmsService.
     */
    public void processResult(Context context, int result, byte[] response, int httpStatusCode,
            boolean handledByCarrierApp) {
        processResult(context, result, response, httpStatusCode, handledByCarrierApp, 0);
    }

    private void processResult(Context context, int result, byte[] response, int httpStatusCode,
            boolean handledByCarrierApp, int retryId) {
        final Uri messageUri = persistIfRequired(context, result, response);

        final String requestId = this.getRequestId();
        currentState = result == Activity.RESULT_OK ? MmsRequestState.Success
                : MmsRequestState.Failure;
        // As noted in the @param comment above, the httpStatusCode is only set when there's
        // an http failure. On success, such as an http code of 200, the value here will be 0.
        // "httpStatusCode: xxx" is now reported for an http failure only.
        LogUtil.i(requestId, "processResult: "
                + (result == Activity.RESULT_OK ? "success" : "failure(" + result + ")")
                + (httpStatusCode != 0 ? ", httpStatusCode: " + httpStatusCode : "")
                + " handledByCarrierApp: " + handledByCarrierApp
                + " mLastConnectionFailure: " + mLastConnectionFailure);

        // Return MMS HTTP request result via PendingIntent
        final PendingIntent pendingIntent = getPendingIntent();
        if (pendingIntent != null) {
            boolean succeeded = true;
            // Extra information to send back with the pending intent
            Intent fillIn = new Intent();
            if (response != null) {
                succeeded = transferResponse(fillIn, response);
            }
            if (messageUri != null) {
                fillIn.putExtra("uri", messageUri.toString());
            }
            if (result == SmsManager.MMS_ERROR_HTTP_FAILURE && httpStatusCode != 0) {
                fillIn.putExtra(SmsManager.EXTRA_MMS_HTTP_STATUS, httpStatusCode);
            }
            fillIn.putExtra(EXTRA_LAST_CONNECTION_FAILURE_CAUSE_CODE,
                    mLastConnectionFailure);
            fillIn.putExtra(EXTRA_HANDLED_BY_CARRIER_APP, handledByCarrierApp);
            try {
                if (!succeeded) {
                    result = SmsManager.MMS_ERROR_IO_ERROR;
                }
                reportPossibleAnomaly(result, httpStatusCode);
                pendingIntent.send(context, result, fillIn);
                mMmsStats.addAtomToStorage(result, retryId, handledByCarrierApp, mMessageId);
            } catch (PendingIntent.CanceledException e) {
                LogUtil.e(requestId, "Sending pending intent canceled", e);
            }
        }

        revokeUriPermission(context);
    }

    private void reportPossibleAnomaly(int result, int httpStatusCode) {
        switch (result) {
            case SmsManager.MMS_ERROR_HTTP_FAILURE:
                if (isPoorSignal()) {
                    LogUtil.i(this.toString(), "Poor Signal");
                    break;
                }
            case SmsManager.MMS_ERROR_INVALID_APN:
            case SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS:
            case SmsManager.MMS_ERROR_UNSPECIFIED:
            case SmsManager.MMS_ERROR_IO_ERROR:
                String message = "MMS failed";
                LogUtil.i(this.toString(),
                        message + " with error: " + result + " httpStatus:" + httpStatusCode);
                reportAnomaly(message, generateUUID(result, httpStatusCode));
                break;
            default:
                break;
        }
    }

    private void reportAnomaly(@NonNull String anomalyMsg, @NonNull UUID uuid) {
        TelephonyManager telephonyManager =
                mContext.getSystemService(TelephonyManager.class)
                        .createForSubscriptionId(mSubId);
        if (telephonyManager != null) {
            AnomalyReporter.reportAnomaly(
                    uuid,
                    anomalyMsg,
                    telephonyManager.getSimCarrierId());
        }
    }

    private UUID generateUUID(int result, int httpStatusCode) {
        long lresult = result;
        long lhttpStatusCode = httpStatusCode;
        return new UUID(MmsConstants.MMS_ANOMALY_UUID.getMostSignificantBits(),
                MmsConstants.MMS_ANOMALY_UUID.getLeastSignificantBits()
                        + ((lhttpStatusCode << 32) + lresult));
    }

    private boolean isPoorSignal() {
        // Check Wifi signal strength when IMS registers via Wifi
        if (isImsOnWifi()) {
            int rssi = 0;
            WifiManager wifiManager = mContext.getSystemService(WifiManager.class);
            final WifiInfo wifiInfo = wifiManager.getConnectionInfo();
            if (wifiInfo != null) {
                rssi = wifiInfo.getRssi();
            } else {
                return false;
            }
            final int wifiLevel = wifiManager.calculateSignalLevel(rssi);
            LogUtil.d(this.toString(), "Wifi signal rssi: " + rssi + " level:" + wifiLevel);
            if (wifiLevel <= SIGNAL_LEVEL_THRESHOLD) {
                return true;
            }
            return false;
        } else {
            // Check cellular signal strength
            final TelephonyManager telephonyManager = mContext.getSystemService(
                    TelephonyManager.class).createForSubscriptionId(mSubId);
            final int cellLevel = telephonyManager.getSignalStrength().getLevel();
            LogUtil.d(this.toString(), "Cellular signal level:" + cellLevel);
            if (cellLevel <= SIGNAL_LEVEL_THRESHOLD) {
                return true;
            }
            return false;
        }
    }

    private boolean isImsOnWifi() {
        ImsMmTelManager imsManager;
        try {
            imsManager = ImsMmTelManager.createForSubscriptionId(mSubId);
        } catch (IllegalArgumentException e) {
            LogUtil.e(this.toString(), "invalid subid:" + mSubId);
            return false;
        }
        if (imsManager != null) {
            return imsManager.isAvailable(MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE,
                    ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN);
        } else {
            return false;
        }
    }

    /**
     * Returns true if sending / downloading using the carrier app has failed and completes the
     * action using platform API's, otherwise false.
     */
    protected boolean maybeFallbackToRegularDelivery(int carrierMessagingAppResult) {
        if (carrierMessagingAppResult
                == CarrierMessagingService.SEND_STATUS_RETRY_ON_CARRIER_NETWORK
                || carrierMessagingAppResult
                        == CarrierMessagingService.DOWNLOAD_STATUS_RETRY_ON_CARRIER_NETWORK) {
            LogUtil.d(this.toString(), "Sending/downloading MMS by IP failed. "
                    + MmsService.formatCrossStackMessageId(mMessageId));
            mRequestManager.addSimRequest(MmsRequest.this);
            return true;
        } else {
            return false;
        }
    }

    /**
     * Converts from {@code carrierMessagingAppResult} to a platform result code.
     */
    protected static int toSmsManagerResult(int carrierMessagingAppResult) {
        switch (carrierMessagingAppResult) {
            case CarrierMessagingService.SEND_STATUS_OK:
                return Activity.RESULT_OK;
            case CarrierMessagingService.SEND_STATUS_RETRY_ON_CARRIER_NETWORK:
                return SmsManager.MMS_ERROR_RETRY;
            default:
                return SmsManager.MMS_ERROR_UNSPECIFIED;
        }
    }

    /**
     * Converts from {@code carrierMessagingAppResult} to a platform result code for outbound MMS
     * requests.
     */
    protected static int toSmsManagerResultForOutboundMms(int carrierMessagingAppResult) {
        if (Flags.temporaryFailuresInCarrierMessagingService()) {
            switch (carrierMessagingAppResult) {
                case CarrierMessagingService.SEND_STATUS_OK:
                    // TODO: b/378931437 - Update to an SmsManager result code when one is
                    // available.
                    return Activity.RESULT_OK;
                case CarrierMessagingService.SEND_STATUS_RETRY_ON_CARRIER_NETWORK, // fall through
                    CarrierMessagingService.SEND_STATUS_MMS_ERROR_RETRY:
                    return SmsManager.MMS_ERROR_RETRY;
                case CarrierMessagingService.SEND_STATUS_ERROR: // fall through
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_UNSPECIFIED:
                    return SmsManager.MMS_ERROR_UNSPECIFIED;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_INVALID_APN:
                    return SmsManager.MMS_ERROR_INVALID_APN;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_UNABLE_CONNECT_MMS:
                    return SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_HTTP_FAILURE:
                    return SmsManager.MMS_ERROR_HTTP_FAILURE;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_IO_ERROR:
                    return SmsManager.MMS_ERROR_IO_ERROR;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_CONFIGURATION_ERROR:
                    return SmsManager.MMS_ERROR_CONFIGURATION_ERROR;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_NO_DATA_NETWORK:
                    return SmsManager.MMS_ERROR_NO_DATA_NETWORK;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_INVALID_SUBSCRIPTION_ID:
                    return SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_INACTIVE_SUBSCRIPTION:
                    return SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_DATA_DISABLED:
                    return SmsManager.MMS_ERROR_DATA_DISABLED;
                case CarrierMessagingService.SEND_STATUS_MMS_ERROR_MMS_DISABLED_BY_CARRIER:
                    return SmsManager.MMS_ERROR_MMS_DISABLED_BY_CARRIER;
                default:
                    return SmsManager.MMS_ERROR_UNSPECIFIED;
            }
        } else {
            return toSmsManagerResult(carrierMessagingAppResult);
        }
    }

    /**
     * Converts from {@code carrierMessagingAppResult} to a platform result code for download MMS
     * requests.
     */
    protected static int toSmsManagerResultForInboundMms(int carrierMessagingAppResult) {
        if (Flags.temporaryFailuresInCarrierMessagingService()) {
            switch (carrierMessagingAppResult) {
                case CarrierMessagingService.DOWNLOAD_STATUS_OK:
                    return Activity.RESULT_OK;
                case CarrierMessagingService.DOWNLOAD_STATUS_RETRY_ON_CARRIER_NETWORK:
                    return SmsManager.MMS_ERROR_RETRY;
                case CarrierMessagingService.DOWNLOAD_STATUS_ERROR: // fall through
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_UNSPECIFIED:
                    return SmsManager.MMS_ERROR_UNSPECIFIED;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_INVALID_APN:
                    return SmsManager.MMS_ERROR_INVALID_APN;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_UNABLE_CONNECT_MMS:
                    return SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_HTTP_FAILURE:
                    return SmsManager.MMS_ERROR_HTTP_FAILURE;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_IO_ERROR:
                    return SmsManager.MMS_ERROR_IO_ERROR;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_RETRY:
                    return SmsManager.MMS_ERROR_RETRY;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_CONFIGURATION_ERROR:
                    return SmsManager.MMS_ERROR_CONFIGURATION_ERROR;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_NO_DATA_NETWORK:
                    return SmsManager.MMS_ERROR_NO_DATA_NETWORK;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_INVALID_SUBSCRIPTION_ID:
                    return SmsManager.MMS_ERROR_INVALID_SUBSCRIPTION_ID;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_INACTIVE_SUBSCRIPTION:
                    return SmsManager.MMS_ERROR_INACTIVE_SUBSCRIPTION;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_DATA_DISABLED:
                    return SmsManager.MMS_ERROR_DATA_DISABLED;
                case CarrierMessagingService.DOWNLOAD_STATUS_MMS_ERROR_MMS_DISABLED_BY_CARRIER:
                    return SmsManager.MMS_ERROR_MMS_DISABLED_BY_CARRIER;
                default:
                    return SmsManager.MMS_ERROR_UNSPECIFIED;
            }
        } else {
            return toSmsManagerResult(carrierMessagingAppResult);
        }
    }

    @Override
    public String toString() {
        return getClass().getSimpleName() + '@' + Integer.toHexString(hashCode())
                + " " + MmsService.formatCrossStackMessageId(mMessageId)
                + " subId: " + mSubId
                + " currentState: \"" + currentState.name() + "\""
                + " result: " + result;
    }

    protected String getRequestId() {
        return this.toString();
    }

    /**
     * Making the HTTP request to MMSC
     *
     * @param context The context
     * @param netMgr The current {@link MmsNetworkManager}
     * @param apn The APN setting
     * @return The HTTP response data
     * @throws MmsHttpException If any network error happens
     */
    protected abstract byte[] doHttp(Context context, MmsNetworkManager netMgr, ApnSettings apn)
            throws MmsHttpException;

    /**
     * @return The PendingIntent associate with the MMS sending invocation
     */
    protected abstract PendingIntent getPendingIntent();

    /**
     * @return The queue should be used by this request, 0 is sending and 1 is downloading
     */
    protected abstract int getQueueType();

    /**
     * Persist message into telephony if required (i.e. when auto-persisting is on or
     * the calling app is non-default sms app for sending)
     *
     * @param context The context
     * @param result The result code of execution
     * @param response The response body
     * @return The persisted URI of the message or null if we don't persist or fail
     */
    protected abstract Uri persistIfRequired(Context context, int result, byte[] response);

    /**
     * Prepare to make the HTTP request - will download message for sending
     * @return true if preparation succeeds (and request can proceed) else false
     */
    protected abstract boolean prepareForHttpRequest();

    /**
     * Transfer the received response to the caller
     *
     * @param fillIn the intent that will be returned to the caller
     * @param response the pdu to transfer
     * @return true if response transfer succeeds else false
     */
    protected abstract boolean transferResponse(Intent fillIn, byte[] response);

    /**
     * Revoke the content URI permission granted by the MMS app to the phone package.
     *
     * @param context The context
     */
    protected abstract void revokeUriPermission(Context context);

    /**
     * Base class for handling carrier app send / download result.
     */
    protected abstract class CarrierMmsActionCallback implements CarrierMessagingCallback {
        @Override
        public void onSendSmsComplete(int result, int messageRef) {
            LogUtil.e("Unexpected onSendSmsComplete call for "
                    + MmsService.formatCrossStackMessageId(mMessageId)
                    + " with result: " + result);
        }

        @Override
        public void onSendMultipartSmsComplete(int result, int[] messageRefs) {
            LogUtil.e("Unexpected onSendMultipartSmsComplete call for "
                    + MmsService.formatCrossStackMessageId(mMessageId)
                    + " with result: " + result);
        }

        @Override
        public void onReceiveSmsComplete(int result) {
            LogUtil.e("Unexpected onFilterComplete call for "
                    + MmsService.formatCrossStackMessageId(mMessageId)
                    + " with result: " + result);
        }
    }

    /**
     * Get the size of the pdu to send or download.
     */
    protected abstract long getPayloadSize();

    /**
     * Determine whether the send or to-be-downloaded pdu is within size limits for the
     * current connection.
     */
    @VisibleForTesting
    public boolean canTransferPayloadOnCurrentNetwork() {
        ServiceState serviceState = mTelephonyManager.getServiceState();
        if (serviceState == null) {
            // serviceState can be null when the subscription is inactive
            // or when there was an error communicating with the phone process.
            LogUtil.d("canTransferPayloadOnCurrentNetwork serviceState null");
            return true;    // assume we're not connected to a satellite
        }
        long payloadSize = getPayloadSize();
        int maxPduSize = mMmsConfig
                .getInt(CarrierConfigManager.KEY_MMS_MAX_NTN_PAYLOAD_SIZE_BYTES_INT);
        LogUtil.d("canTransferPayloadOnCurrentNetwork payloadSize: " + payloadSize
                + " maxPduSize: " + maxPduSize);
        return payloadSize > 0 && (maxPduSize == -1 || payloadSize <= maxPduSize);
    }
}