| /* |
| * 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.internal.telephony.d2d; |
| |
| import android.annotation.NonNull; |
| import android.net.Uri; |
| import android.os.Handler; |
| import android.telecom.Log; |
| import android.telephony.ims.ImsCallProfile; |
| import android.telephony.ims.RtpHeaderExtension; |
| import android.telephony.ims.RtpHeaderExtensionType; |
| import android.util.ArraySet; |
| |
| import com.android.internal.telephony.BiMap; |
| |
| import java.util.Objects; |
| import java.util.Optional; |
| import java.util.Set; |
| import java.util.stream.Collectors; |
| |
| /** |
| * Implements a transport protocol which makes use of RTP header extensions to communicate between |
| * two devices. |
| * <p> |
| * Two types of device to device communications are supported, |
| * {@link #DEVICE_STATE_RTP_HEADER_EXTENSION} messages which communicate attributes such as the |
| * device service level and battery, and {@link #CALL_STATE_RTP_HEADER_EXTENSION} which communicates |
| * information pertaining to an ongoing call. |
| * <p> |
| * When the ImsService negotiates the media for a call using SDP it will also potentially negotiate |
| * the supported RTP header extension types which both parties of the call agree upon. When a call |
| * first begins if the accepted RTP header extension URIs matches the two well defined URIs we |
| * define here, then we can assume the other party supports device to device communication using |
| * RTP header extensions. |
| * <p> |
| * It is, however, possible that network signalling causes a failure to successfully negotiate the |
| * RTP header extension types which both sides agree upon. In this case we will wait for a short |
| * period of time to see if we receive an RTP header extension which corresponds to one of the |
| * local identifiers we would have expected to negotiation. If such an RTP header extension is |
| * received in a timely manner, we can assume that the other party is capable of using RTP header |
| * extensions to communicate even though the RTP extension type URIs did not successfully negotiate. |
| * If we do not receive a valid extension in this case, we will consider negotiation for this |
| * transport to have failed. |
| */ |
| public class RtpTransport implements TransportProtocol, RtpAdapter.Callback { |
| /** |
| * {@link Uri} identifier for an RTP header extension used to communicate device state during |
| * calls. |
| */ |
| public static Uri DEVICE_STATE_RTP_HEADER_EXTENSION = |
| Uri.parse("http://develop.android.com/122020/d2dcomm#device-state"); |
| |
| /** |
| * {@link Uri} identifier for an RTP header extension used to communication call state during |
| * calls. |
| */ |
| public static Uri CALL_STATE_RTP_HEADER_EXTENSION = |
| Uri.parse("http://develop.android.com/122020/d2dcomm#call-state"); |
| |
| /** |
| * Default local identifier for device state RTP header extensions. |
| */ |
| public static int DEVICE_STATE_LOCAL_IDENTIFIER = 10; |
| |
| /** |
| * Default local identifier for call state RTP header extensions. |
| */ |
| public static int CALL_STATE_LOCAL_IDENTIFIER = 11; |
| |
| /** |
| * {@link RtpHeaderExtensionType} for device state communication. |
| */ |
| public static RtpHeaderExtensionType DEVICE_STATE_RTP_HEADER_EXTENSION_TYPE = |
| new RtpHeaderExtensionType(DEVICE_STATE_LOCAL_IDENTIFIER, |
| DEVICE_STATE_RTP_HEADER_EXTENSION); |
| |
| /** |
| * {@link RtpHeaderExtensionType} for call state communication. |
| */ |
| public static RtpHeaderExtensionType CALL_STATE_RTP_HEADER_EXTENSION_TYPE = |
| new RtpHeaderExtensionType(CALL_STATE_LOCAL_IDENTIFIER, |
| CALL_STATE_RTP_HEADER_EXTENSION); |
| |
| |
| /** |
| * See {@link #generateRtpHeaderExtension(Communicator.Message)} for more information; indicates |
| * the offset of the parameter value in the RTP header extension payload. |
| */ |
| public static final int RTP_PARAMETER_BIT_OFFSET = 4; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_RADIO_ACCESS_TYPE} msg. |
| */ |
| public static final byte RTP_CALL_STATE_MSG_RADIO_ACCESS_TYPE_BITS = 0b0001; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_AUDIO_CODEC} msg. |
| */ |
| public static final byte RTP_CALL_STATE_MSG_CODEC_BITS = 0b0010; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_DEVICE_BATTERY_STATE} msg. |
| */ |
| public static final byte RTP_DEVICE_STATE_MSG_BATTERY_BITS = 0b0001; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_DEVICE_NETWORK_COVERAGE} msg. |
| */ |
| public static final byte RTP_DEVICE_STATE_MSG_NETWORK_COVERAGE_BITS = 0b0010; |
| |
| /** |
| * Provides a mapping between the various {@code Communicator#MESSAGE_*} values and their bit |
| * representation in an RTP header extension payload. Used to translate outgoing message types |
| * to an RTP payload and to interpret incoming RTP payloads and translate them back into message |
| * types. |
| */ |
| private static final BiMap<Integer, Byte> CALL_STATE_MSG_TYPE_TO_RTP_BITS = new BiMap<>(); |
| private static final BiMap<Integer, Byte> DEVICE_STATE_MSG_TYPE_TO_RTP_BITS = new BiMap<>(); |
| static { |
| CALL_STATE_MSG_TYPE_TO_RTP_BITS.put( |
| Communicator.MESSAGE_CALL_RADIO_ACCESS_TYPE, |
| RTP_CALL_STATE_MSG_RADIO_ACCESS_TYPE_BITS); |
| CALL_STATE_MSG_TYPE_TO_RTP_BITS.put( |
| Communicator.MESSAGE_CALL_AUDIO_CODEC, |
| RTP_CALL_STATE_MSG_CODEC_BITS); |
| DEVICE_STATE_MSG_TYPE_TO_RTP_BITS.put( |
| Communicator.MESSAGE_DEVICE_BATTERY_STATE, |
| RTP_DEVICE_STATE_MSG_BATTERY_BITS); |
| DEVICE_STATE_MSG_TYPE_TO_RTP_BITS.put( |
| Communicator.MESSAGE_DEVICE_NETWORK_COVERAGE, |
| RTP_DEVICE_STATE_MSG_NETWORK_COVERAGE_BITS); |
| } |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_RADIO_ACCESS_TYPE} data |
| * payload. Corresponds to {@link Communicator#RADIO_ACCESS_TYPE_LTE}. |
| */ |
| public static final byte RTP_RAT_VALUE_LTE_BITS = 0b0001 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_RADIO_ACCESS_TYPE} data |
| * payload. Corresponds to {@link Communicator#RADIO_ACCESS_TYPE_IWLAN}. |
| */ |
| public static final byte RTP_RAT_VALUE_WLAN_BITS = 0b0010 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_RADIO_ACCESS_TYPE} data |
| * payload. Corresponds to {@link Communicator#RADIO_ACCESS_TYPE_NR}. |
| */ |
| public static final byte RTP_RAT_VALUE_NR_BITS = 0b0011 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * Provides a mapping between the various {@code Communicator#RADIO_ACCESS_TYPE_*} values and |
| * their bit representation in an RTP header extension payload. |
| */ |
| private static final BiMap<Integer, Byte> RAT_VALUE_TO_RTP_BITS = new BiMap<>(); |
| static { |
| RAT_VALUE_TO_RTP_BITS.put( |
| Communicator.RADIO_ACCESS_TYPE_IWLAN, RTP_RAT_VALUE_WLAN_BITS); |
| RAT_VALUE_TO_RTP_BITS.put( |
| Communicator.RADIO_ACCESS_TYPE_LTE, RTP_RAT_VALUE_LTE_BITS); |
| RAT_VALUE_TO_RTP_BITS.put( |
| Communicator.RADIO_ACCESS_TYPE_NR, RTP_RAT_VALUE_NR_BITS); |
| } |
| |
| /** |
| * RTP header extension bits set for {@link Communicator#MESSAGE_CALL_AUDIO_CODEC} data |
| * payload. Corresponds to {@link Communicator#AUDIO_CODEC_EVS}. |
| */ |
| public static final byte RTP_CODEC_VALUE_EVS_BITS = 0b0001 << RTP_PARAMETER_BIT_OFFSET; |
| public static final byte RTP_CODEC_VALUE_AMR_WB_BITS = 0b0010 << RTP_PARAMETER_BIT_OFFSET; |
| public static final byte RTP_CODEC_VALUE_AMR_NB_BITS = 0b0011 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * Provides a mapping between the various {@code Communicator#AUDIO_CODEC_*} values and |
| * their bit representation in an RTP header extension payload. |
| */ |
| private static final BiMap<Integer, Byte> CODEC_VALUE_TO_RTP_BITS = new BiMap<>(); |
| static { |
| CODEC_VALUE_TO_RTP_BITS.put( |
| Communicator.AUDIO_CODEC_EVS, RTP_CODEC_VALUE_EVS_BITS); |
| CODEC_VALUE_TO_RTP_BITS.put( |
| Communicator.AUDIO_CODEC_AMR_WB, RTP_CODEC_VALUE_AMR_WB_BITS); |
| CODEC_VALUE_TO_RTP_BITS.put( |
| Communicator.AUDIO_CODEC_AMR_NB, RTP_CODEC_VALUE_AMR_NB_BITS); |
| } |
| |
| public static final byte RTP_BATTERY_STATE_LOW_BITS = 0b0000 << RTP_PARAMETER_BIT_OFFSET; |
| public static final byte RTP_BATTERY_STATE_GOOD_BITS = 0b0001 << RTP_PARAMETER_BIT_OFFSET; |
| public static final byte RTP_BATTERY_STATE_CHARGING_BITS = 0b0011 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * Provides a mapping between the various {@code Communicator#BATTERY_STATE_*} values and |
| * their bit representation in an RTP header extension payload. |
| */ |
| private static final BiMap<Integer, Byte> BATTERY_STATE_VALUE_TO_RTP_BITS = new BiMap<>(); |
| static { |
| BATTERY_STATE_VALUE_TO_RTP_BITS.put( |
| Communicator.BATTERY_STATE_LOW, RTP_BATTERY_STATE_LOW_BITS); |
| BATTERY_STATE_VALUE_TO_RTP_BITS.put( |
| Communicator.BATTERY_STATE_GOOD, RTP_BATTERY_STATE_GOOD_BITS); |
| BATTERY_STATE_VALUE_TO_RTP_BITS.put( |
| Communicator.BATTERY_STATE_CHARGING, RTP_BATTERY_STATE_CHARGING_BITS); |
| } |
| |
| public static final byte RTP_NETWORK_COVERAGE_POOR_BITS = 0b0000 << RTP_PARAMETER_BIT_OFFSET; |
| public static final byte RTP_NETWORK_COVERAGE_GOOD_BITS = 0b0001 << RTP_PARAMETER_BIT_OFFSET; |
| |
| /** |
| * Provides a mapping between the various {@code Communicator#COVERAGE_*} values and |
| * their bit representation in an RTP header extension payload. |
| */ |
| private static final BiMap<Integer, Byte> NETWORK_COVERAGE_VALUE_TO_RTP_BITS = new BiMap<>(); |
| static { |
| NETWORK_COVERAGE_VALUE_TO_RTP_BITS.put( |
| Communicator.COVERAGE_POOR, RTP_NETWORK_COVERAGE_POOR_BITS); |
| NETWORK_COVERAGE_VALUE_TO_RTP_BITS.put( |
| Communicator.COVERAGE_GOOD, RTP_NETWORK_COVERAGE_GOOD_BITS); |
| } |
| |
| /** |
| * Indicates that the transport is not yet ready for use and negotiation has not yet completed. |
| */ |
| public static final int PROTOCOL_STATUS_NEGOTIATION_REQUIRED = 1; |
| |
| /** |
| * Indicates that the agreed upon RTP header extension types (see |
| * {@link RtpAdapter#getAcceptedRtpHeaderExtensions()}) did not specify both the |
| * {@link #DEVICE_STATE_RTP_HEADER_EXTENSION} and {@link #CALL_STATE_RTP_HEADER_EXTENSION |
| * RTP header extension types. We are not going to wait a short time to see if we receive an |
| * incoming RTP packet with one of the local identifiers we'd normally expect associated with |
| * these header extension {@link Uri}s. If we do receive a valid RTP header extension we will |
| * move to the {@link #PROTOCOL_STATUS_NEGOTIATION_COMPLETE} status. If we do not receive a |
| * valid RTP header extension we move to {@link #PROTOCOL_STATUS_NEGOTIATION_FAILED} and report |
| * the failure via {@link Callback#onNegotiationFailed(TransportProtocol) }. |
| */ |
| public static final int PROTOCOL_STATUS_NEGOTIATION_WAITING_ON_PACKET = 2; |
| |
| /** |
| * Indicates we either agreed upon the required header extensions, or received a valid packet |
| * despite not having agreed upon required header extensions. The transport is ready to use at |
| * this point. |
| */ |
| public static final int PROTOCOL_STATUS_NEGOTIATION_COMPLETE = 3; |
| |
| /** |
| * Indicates protocol negotiation failed. |
| */ |
| public static final int PROTOCOL_STATUS_NEGOTIATION_FAILED = 4; |
| |
| /** |
| * Callback which is used to report back to the {@link Communicator} about the status of |
| * protocol negotiation and incoming messages. |
| */ |
| private TransportProtocol.Callback mCallback; |
| |
| /** |
| * Adapter which abstracts out the details of sending/receiving RTP header extensions. |
| */ |
| private final RtpAdapter mRtpAdapter; |
| |
| /** |
| * Configuration adapter for timeouts related to protocol setup. |
| */ |
| private final Timeouts.Adapter mTimeoutsAdapter; |
| |
| /** |
| * Handler for posting future events. |
| */ |
| private final Handler mHandler; |
| |
| /** |
| * {@code true} if the carrier supports negotiating the RTP header extensions using SDP. |
| * If {@code true}, we can expected the |
| * {@link ImsCallProfile#getAcceptedRtpHeaderExtensionTypes()} to contain the SDP negotiated RTP |
| * header extensions. If {@code false} we will assume the protocol is negotiated only after |
| * receiving an RTP header extension of the expected type. |
| */ |
| private final boolean mIsSdpNegotiationSupported; |
| |
| /** |
| * Protocol status. |
| */ |
| private int mProtocolStatus = PROTOCOL_STATUS_NEGOTIATION_REQUIRED; |
| |
| /** |
| * The supported RTP header extension types. |
| */ |
| private ArraySet<RtpHeaderExtensionType> mSupportedRtpHeaderExtensionTypes = new ArraySet<>(); |
| |
| /** |
| * Initializes the {@link RtpTransport}. |
| * @param rtpAdapter Adapter for abstract send/receive of RTP header extension data. |
| * @param timeoutsAdapter Timeouts adapter for dealing with time based configurations. |
| * @param handler Handler for posting future events. |
| * @param isSdpNegotiationSupported Indicates whether SDP negotiation |
| */ |
| public RtpTransport(RtpAdapter rtpAdapter, Timeouts.Adapter timeoutsAdapter, Handler handler, |
| boolean isSdpNegotiationSupported) { |
| mRtpAdapter = rtpAdapter; |
| mTimeoutsAdapter = timeoutsAdapter; |
| mHandler = handler; |
| mIsSdpNegotiationSupported = isSdpNegotiationSupported; |
| } |
| |
| /** |
| * Sets the Callback for this transport. Used to report back received messages. |
| * @param callback The callback. |
| */ |
| @Override |
| public void setCallback(Callback callback) { |
| mCallback = callback; |
| } |
| |
| /** |
| * Begin transport protocol negotiation at the request of the framework. |
| * |
| * If the {@link #DEVICE_STATE_RTP_HEADER_EXTENSION} and |
| * {@link #CALL_STATE_RTP_HEADER_EXTENSION} extension {@link Uri}s are part of the accepted |
| * extension types, we consider the negotiation successful. |
| * |
| * TODO: If they are not in the accepted extensions, we will wait a short period of time to |
| * receive a valid RTP header extension we recognize. |
| */ |
| @Override |
| public void startNegotiation() { |
| Set<RtpHeaderExtensionType> acceptedExtensions = |
| mRtpAdapter.getAcceptedRtpHeaderExtensions(); |
| mSupportedRtpHeaderExtensionTypes.addAll(acceptedExtensions); |
| |
| Log.i(this, "startNegotiation: supportedExtensions=%s", mSupportedRtpHeaderExtensionTypes |
| .stream() |
| .map(e -> e.toString()) |
| .collect(Collectors.joining(","))); |
| |
| if (mIsSdpNegotiationSupported) { |
| boolean areExtensionsAvailable = acceptedExtensions.stream().anyMatch( |
| e -> e.getUri().equals(DEVICE_STATE_RTP_HEADER_EXTENSION)) |
| && acceptedExtensions.stream().anyMatch( |
| e -> e.getUri().equals(CALL_STATE_RTP_HEADER_EXTENSION)); |
| |
| if (areExtensionsAvailable) { |
| // Headers were negotiated during SDP, so we can assume negotiation is complete and |
| // signal to the communicator that we can use this transport. |
| mProtocolStatus = PROTOCOL_STATUS_NEGOTIATION_COMPLETE; |
| Log.i(this, "startNegotiation: header extensions available, negotiation success"); |
| notifyProtocolReady(); |
| } else { |
| // Headers failed to be negotiated during SDP. Assume protocol is not available. |
| // TODO: Implement fallback logic where we still try an SDP probe/response. |
| mProtocolStatus = PROTOCOL_STATUS_NEGOTIATION_FAILED; |
| Log.i(this, |
| "startNegotiation: header extensions not available; negotiation failed"); |
| notifyProtocolUnavailable(); |
| } |
| } else { |
| Log.i(this, "startNegotiation: SDP negotiation not supported; negotiation complete"); |
| // TODO: This is temporary; we will need to implement a probe/response in this scenario |
| // if SDP is not supported. For now we will just assume the protocol is ready. |
| notifyProtocolReady(); |
| } |
| } |
| |
| /** |
| * Handles sending messages using the RTP transport. Generates valid {@link RtpHeaderExtension} |
| * instances for each message to send. |
| * @param messages The messages to send. |
| */ |
| @Override |
| public void sendMessages(Set<Communicator.Message> messages) { |
| Set<RtpHeaderExtension> toSend = messages.stream().map(m -> generateRtpHeaderExtension(m)) |
| .collect(Collectors.toSet()); |
| Log.i(this, "sendMessages: sending=%s", messages); |
| mRtpAdapter.sendRtpHeaderExtensions(toSend); |
| } |
| |
| /** |
| * Forces the protocol status to negotiated; for test purposes. |
| */ |
| @Override |
| public void forceNegotiated() { |
| // If there is no supported RTP header extensions we need to fake it. |
| if (mSupportedRtpHeaderExtensionTypes == null |
| || mSupportedRtpHeaderExtensionTypes.isEmpty()) { |
| mSupportedRtpHeaderExtensionTypes.add(DEVICE_STATE_RTP_HEADER_EXTENSION_TYPE); |
| mSupportedRtpHeaderExtensionTypes.add(CALL_STATE_RTP_HEADER_EXTENSION_TYPE); |
| } |
| mProtocolStatus = PROTOCOL_STATUS_NEGOTIATION_COMPLETE; |
| } |
| |
| /** |
| * Forces the protocol status to un-negotiated; for test purposes. |
| */ |
| @Override |
| public void forceNotNegotiated() { |
| mProtocolStatus = PROTOCOL_STATUS_NEGOTIATION_REQUIRED; |
| } |
| |
| /** |
| * Called by the platform when RTP header extensions are received and need to be translated to |
| * concrete messages. |
| * Results in a callback via |
| * {@link com.android.internal.telephony.d2d.TransportProtocol.Callback#onMessagesReceived(Set)} |
| * to notify when incoming messages are received. |
| * @param extensions The received RTP header extensions. |
| */ |
| @Override |
| public void onRtpHeaderExtensionsReceived(@NonNull Set<RtpHeaderExtension> extensions) { |
| Set<Communicator.Message> messages = extensions.stream().map(e -> extractMessage(e)) |
| .filter(Objects::nonNull) |
| .collect(Collectors.toSet()); |
| if (messages.size() == 0) { |
| return; |
| } |
| mCallback.onMessagesReceived(messages); |
| } |
| |
| /** |
| * Given a {@link RtpHeaderExtension} received from the network, parse out an found message. |
| * @param extension The RTP header extension to parse. |
| * @return The message, or {@code null} if no valid message found. |
| */ |
| private Communicator.Message extractMessage(@NonNull RtpHeaderExtension extension) { |
| // First determine the URI to figure out the general classification of the message. |
| Optional<Uri> foundUri = mSupportedRtpHeaderExtensionTypes.stream() |
| .filter(et -> et.getLocalIdentifier() == extension.getLocalIdentifier()) |
| .map(et -> et.getUri()) |
| .findFirst(); |
| if (!foundUri.isPresent()) { |
| Log.w(this, "extractMessage: localIdentifier=%d not supported.", |
| extension.getLocalIdentifier()); |
| return null; |
| } |
| |
| if (extension.getExtensionData() == null || extension.getExtensionData().length != 1) { |
| Log.w(this, "extractMessage: localIdentifier=%d message with invalid data length.", |
| extension.getLocalIdentifier()); |
| return null; |
| } |
| |
| Uri uri = foundUri.get(); |
| |
| // Extract the bits which are the message type. |
| byte messageTypeBits = (byte) (extension.getExtensionData()[0] & 0b1111); |
| byte messageValueBits = (byte) (extension.getExtensionData()[0] |
| & (0b1111 << RTP_PARAMETER_BIT_OFFSET)); |
| |
| int messageType; |
| int messageValue; |
| if (DEVICE_STATE_RTP_HEADER_EXTENSION.equals(uri)) { |
| Integer type = DEVICE_STATE_MSG_TYPE_TO_RTP_BITS.getKey(messageTypeBits); |
| if (type == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d message with invalid type %s.", |
| extension.getLocalIdentifier(), Integer.toBinaryString(messageTypeBits)); |
| return null; |
| } |
| messageType = type; |
| switch (messageType) { |
| case Communicator.MESSAGE_DEVICE_BATTERY_STATE: |
| Integer val = BATTERY_STATE_VALUE_TO_RTP_BITS.getKey(messageValueBits); |
| if (val == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d, battery state msg with " |
| + "invalid value=%s", |
| extension.getLocalIdentifier(), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| messageValue = val; |
| break; |
| case Communicator.MESSAGE_DEVICE_NETWORK_COVERAGE: |
| Integer val2 = NETWORK_COVERAGE_VALUE_TO_RTP_BITS.getKey(messageValueBits); |
| if (val2 == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d, network coverage msg with " |
| + "invalid value=%s", |
| extension.getLocalIdentifier(), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| messageValue = val2; |
| break; |
| default: |
| Log.w(this, "messageType=%s, value=%s; invalid value", |
| Integer.toBinaryString(messageTypeBits), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| } else if (CALL_STATE_RTP_HEADER_EXTENSION.equals(uri)) { |
| Integer typeValue = CALL_STATE_MSG_TYPE_TO_RTP_BITS.getKey(messageTypeBits); |
| if (typeValue == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d, network coverage msg with " |
| + "invalid type=%s", |
| extension.getLocalIdentifier(), |
| Integer.toBinaryString(messageTypeBits)); |
| return null; |
| } |
| messageType = typeValue; |
| switch (messageType) { |
| case Communicator.MESSAGE_CALL_AUDIO_CODEC: |
| Integer val = CODEC_VALUE_TO_RTP_BITS.getKey(messageValueBits); |
| if (val == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d, audio codec msg with " |
| + "invalid value=%s", |
| extension.getLocalIdentifier(), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| messageValue = val; |
| break; |
| case Communicator.MESSAGE_CALL_RADIO_ACCESS_TYPE: |
| Integer val2 = RAT_VALUE_TO_RTP_BITS.getKey(messageValueBits); |
| if (val2 == null) { |
| Log.w(this, "extractMessage: localIdentifier=%d, rat type msg with " |
| + "invalid value=%s", |
| extension.getLocalIdentifier(), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| messageValue = val2; |
| break; |
| default: |
| Log.w(this, "messageType=%s, value=%s; invalid value", |
| Integer.toBinaryString(messageTypeBits), |
| Integer.toBinaryString(messageValueBits)); |
| return null; |
| } |
| } else { |
| Log.w(this, "invalid uri=%s", uri); |
| return null; |
| } |
| Log.i(this, "extractMessage: messageType=%s, value=%s --> message=%d, value=%d", |
| Integer.toBinaryString(messageTypeBits), Integer.toBinaryString(messageValueBits), |
| messageType, messageValue); |
| return new Communicator.Message(messageType, messageValue); |
| } |
| |
| |
| /** |
| * Generates an {@link RtpHeaderExtension} based on the specified message. |
| * Per RFC8285, RTP header extensions have the format: |
| * (bit) |
| * ___byte__ __byte__ |
| * 1234 5678 12345678 |
| * +----+----+--------+ |
| * | ID | len| data | |
| * +----+----+--------+ |
| * Where ID is the {@link RtpHeaderExtensionType#getLocalIdentifier()}, len indicates the |
| * number of data bytes being sent ({@link RtpHeaderExtension#getExtensionData()}.size()), |
| * and data is the payload of the RTP header extension. |
| * The {@link RtpHeaderExtension} generated here contains the bytes necessary to populate the |
| * data field; the "ID" and "len" fields in the send RTP header extension are populated by the |
| * IMS service. |
| * |
| * This method is responsible for generating the data field in the RTP header extension to be |
| * sent. |
| * |
| * Device to device communication assumes the following format for the single byte payload: |
| * 12345678 |
| * +--------+ |
| * |PPPPVVVV| |
| * +--------+ |
| * Where: |
| * PPPP - 4 bits reserved for indicating the parameter encoded (e.g. it could be an audio |
| * codec ({@link Communicator#MESSAGE_CALL_AUDIO_CODEC})). |
| * VVVV - 4 bits reserved for indicating the value of the parameter encoded (e.g. it could be |
| * the EVS codec ({@link Communicator#AUDIO_CODEC_EVS})). |
| * |
| * @param message The message to be sent via RTP header extensions. |
| * @return An {@link RtpHeaderExtension} representing the message. |
| */ |
| public RtpHeaderExtension generateRtpHeaderExtension(Communicator.Message message) { |
| byte[] payload = new byte[1]; |
| switch (message.getType()) { |
| case Communicator.MESSAGE_CALL_AUDIO_CODEC: |
| payload[0] |= CALL_STATE_MSG_TYPE_TO_RTP_BITS.getValue(message.getType()); |
| payload[0] |= CODEC_VALUE_TO_RTP_BITS.getValue(message.getValue()); |
| return new RtpHeaderExtension( |
| getRtpHeaderExtensionIdentifier(CALL_STATE_RTP_HEADER_EXTENSION), |
| payload); |
| case Communicator.MESSAGE_CALL_RADIO_ACCESS_TYPE: |
| payload[0] |= CALL_STATE_MSG_TYPE_TO_RTP_BITS.getValue(message.getType()); |
| payload[0] |= RAT_VALUE_TO_RTP_BITS.getValue(message.getValue()); |
| return new RtpHeaderExtension( |
| getRtpHeaderExtensionIdentifier(CALL_STATE_RTP_HEADER_EXTENSION), |
| payload); |
| case Communicator.MESSAGE_DEVICE_BATTERY_STATE: |
| payload[0] |= DEVICE_STATE_MSG_TYPE_TO_RTP_BITS.getValue(message.getType()); |
| payload[0] |= BATTERY_STATE_VALUE_TO_RTP_BITS.getValue(message.getValue()); |
| return new RtpHeaderExtension( |
| getRtpHeaderExtensionIdentifier(DEVICE_STATE_RTP_HEADER_EXTENSION), |
| payload); |
| case Communicator.MESSAGE_DEVICE_NETWORK_COVERAGE: |
| payload[0] |= DEVICE_STATE_MSG_TYPE_TO_RTP_BITS.getValue(message.getType()); |
| payload[0] |= NETWORK_COVERAGE_VALUE_TO_RTP_BITS.getValue(message.getValue()); |
| return new RtpHeaderExtension( |
| getRtpHeaderExtensionIdentifier(DEVICE_STATE_RTP_HEADER_EXTENSION), |
| payload); |
| } |
| return null; |
| } |
| |
| /** |
| * Given a {@link Uri} identifying an RTP header extension, return the associated local |
| * identifier. |
| * @param requestedUri the requested {@link Uri}. |
| * @return the local identifier. |
| */ |
| private int getRtpHeaderExtensionIdentifier(Uri requestedUri) { |
| return mSupportedRtpHeaderExtensionTypes.stream() |
| .filter(t -> t.getUri().equals(requestedUri)) |
| .findFirst().get().getLocalIdentifier(); |
| } |
| |
| /** |
| * Notifies the {@link Communicator} that the RTP-based protocol is available.} |
| */ |
| private void notifyProtocolReady() { |
| if (mCallback != null) { |
| mCallback.onNegotiationSuccess(this); |
| } |
| } |
| |
| /** |
| * Notifies the {@link Communicator} that the RTP-based protocol is unavailable. |
| */ |
| private void notifyProtocolUnavailable() { |
| if (mCallback != null) { |
| mCallback.onNegotiationFailed(this); |
| } |
| } |
| } |
