actualQueryParams = buildQueryParamsMap(testUri,
203 | testAccessKeyId,
204 | testSessionToken,
205 | testRegion,
206 | testTimestamp,
207 | testDatestamp);
208 |
209 | assertEquals(expectedQueryParams, actualQueryParams);
210 | }
211 |
212 | @Test
213 | public void when_signStringWithExampleInputs_then_validStringToSignIsReturned() {
214 |
215 | final String credentialScope = "AKIDEXAMPLE/20150830/us-east-1/service/aws4_request";
216 | final String requestDate = "20150830T123600Z";
217 | final String canonicalRequest = METHOD + "\n" +
218 | "/\n" +
219 | "Param1=value1&Param2=value2\n" +
220 | "host:example.amazonaws.com\n" +
221 | "x-amz-date:20150830T123600Z\n" +
222 | "\n" +
223 | SIGNED_HEADERS + ";x-amz-date\n" +
224 | "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
225 |
226 | final String expected = "AWS4-HMAC-SHA256\n" +
227 | "20150830T123600Z\n" +
228 | "AKIDEXAMPLE/20150830/us-east-1/service/" + AWS4_REQUEST_TYPE + "\n" +
229 | "816cd5b414d056048ba4f7c5386d6e0533120fb1fcfa93762cf0fc39e2cf19e0";
230 |
231 | final String actual = signString(requestDate, credentialScope, canonicalRequest);
232 |
233 | assertEquals(expected, actual);
234 |
235 | }
236 |
237 | @Test
238 | public void when_getSignatureKeyWithStringToSign_then_validSignatureKeyReturned() {
239 |
240 | final String stringToSign = ALGORITHM_AWS4_HMAC_SHA_256 + "\n" +
241 | "20150830T123600Z\n" +
242 | "20150830/us-east-1/iam/" + AWS4_REQUEST_TYPE + "\n" +
243 | "f536975d06c0309214f805bb90ccff089219ecd68b2577efef23edd43b7e1a59";
244 |
245 | final byte[] signatureKeyBytes = getSignatureKey("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY",
246 | "20150830", "us-east-1", "iam");
247 |
248 | final String expectedSignature = "c4afb1cc5771d871763a393e44b703571b55cc28424d1a5e86da6ed3c154a4b9";
249 | assertEquals(expectedSignature, BinaryUtils.toHex(signatureKeyBytes));
250 |
251 | final String expectedSignatureString = "5d672d79c15b13162d9279b0855cfba6789a8edb4c82c400e06b5924a6f2b5d7";
252 | assertEquals(expectedSignatureString, BinaryUtils.toHex(hmacSha256(stringToSign, signatureKeyBytes)));
253 |
254 | }
255 |
256 | @Test
257 | public void when_urlEncodeStringWithSpecialCharacters_then_specialCharactersAreURLEncoded() {
258 | final String exampleArn = "arn:aws:kinesisvideo:us-west-2:123456789012:channel/demo-channel/1234567890123";
259 |
260 | final String expected = "arn%3Aaws%3Akinesisvideo%3Aus-west-2%3A123456789012%3Achannel%2Fdemo-channel%2F1234567890123";
261 |
262 | final String actual = urlEncode(exampleArn);
263 |
264 | assertEquals(expected, actual);
265 | }
266 |
267 | @Test(expected = RuntimeException.class)
268 | public void when_urlEncodeGivenNull_then_exceptionIsThrown() {
269 | urlEncode(null);
270 | }
271 |
272 | @Test
273 | public void when_createCredentialScope_then_validCredentialScopeReturned() {
274 | final String expected = "20150930/us-west-2/" + SERVICE + "/" + AWS4_REQUEST_TYPE;
275 |
276 | final String actual = createCredentialScope("us-west-2", "20150930");
277 |
278 | assertEquals(expected, actual);
279 | }
280 |
281 | @Test
282 | public void when_hmacSha256GivenKeyAndData_then_correctSignatureIsReturned() {
283 | byte[] testKey = "testKey".getBytes(UTF_8);
284 |
285 | final String testData = "testData123";
286 |
287 | final String expectedHex = "f8117085c5b8be75d01ce86d16d04e90fedfc4be4668fe75d39e72c92da45568";
288 |
289 | final byte[] actualResult = hmacSha256(testData, testKey);
290 |
291 | final String actualHex = BinaryUtils.toHex(actualResult);
292 |
293 | assertEquals(expectedHex, actualHex);
294 | }
295 |
296 | @Test(expected = RuntimeException.class)
297 | public void when_HmacSha256GivenNulls_then_exceptionThrown() {
298 | hmacSha256(null, null);
299 | }
300 |
301 | @Test
302 | public void when_getTimeStampAroundMidnightUTC_then_dateAndTimeReturnedIsCorrectAndFormattedCorrectly() {
303 | // 1689984000000 = Saturday, July 22, 2023 12:00:00.000 AM (UTC)
304 | final String atMidnightUTC = getTimeStamp(1689984000000L);
305 |
306 | assertEquals("20230722T000000Z", atMidnightUTC);
307 |
308 | // 1689983999999 = Friday, July 21, 2023 11:59:59.999 AM (UTC)
309 | final String rightBeforeMidnightUTC = getTimeStamp(1689983999999L);
310 |
311 | assertEquals("20230721T235959Z", rightBeforeMidnightUTC);
312 | }
313 |
314 | @Test
315 | public void when_getDateStampAroundMidnightUTC_then_dateReturnedIsCorrectAndFormattedCorrectly() {
316 | // 1689984000000 = Saturday, July 22, 2023 12:00:00.000 AM (UTC)
317 | final String atMidnightUTC = getDateStamp(1689984000000L);
318 |
319 | assertEquals("20230722", atMidnightUTC);
320 |
321 | // 1689983999999 = Friday, July 21, 2023 11:59:59.999 AM (UTC)
322 | final String rightBeforeMidnightUTC = getDateStamp(1689983999999L);
323 |
324 | assertEquals("20230721", rightBeforeMidnightUTC);
325 | }
326 |
327 | }
328 |
--------------------------------------------------------------------------------
/app/src/main/java/com/amazonaws/kinesisvideo/utils/AwsV4Signer.java:
--------------------------------------------------------------------------------
1 | package com.amazonaws.kinesisvideo.utils;
2 |
3 | import static com.google.common.hash.Hashing.sha256;
4 | import static org.apache.commons.lang3.StringUtils.EMPTY;
5 | import static org.apache.commons.lang3.StringUtils.isEmpty;
6 | import static org.apache.commons.lang3.StringUtils.isNotEmpty;
7 | import static java.nio.charset.StandardCharsets.UTF_8;
8 |
9 | import com.amazonaws.util.BinaryUtils;
10 | import com.amazonaws.util.DateUtils;
11 | import com.google.common.collect.ImmutableMap;
12 |
13 | import java.net.URI;
14 | import java.net.URLEncoder;
15 | import java.nio.charset.StandardCharsets;
16 | import java.util.ArrayList;
17 | import java.util.Collections;
18 | import java.util.Date;
19 | import java.util.List;
20 | import java.util.Map;
21 | import java.util.Optional;
22 | import java.util.StringJoiner;
23 |
24 | import javax.crypto.Mac;
25 | import javax.crypto.spec.SecretKeySpec;
26 |
27 | @SuppressWarnings({"SpellCheckingInspection", "SameParameterValue"})
28 | public class AwsV4Signer {
29 |
30 | // Guide - https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
31 | // Implementation based on https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html#sig-v4-examples-get-query-string
32 |
33 | /**
34 | * Constructs a WebRTC WebSocket connect URI with Query Parameters to connect to Kinesis Video Signaling.
35 | *
36 | * @param uri The URL to sign.
37 | *
38 | * Connect as Master URL - GetSignalingChannelEndpoint (master role) + Query Parameters: Channel ARN as X-Amz-ChannelARN
39 | * Additional info
40 | *
41 | * Connect as Viewer URL - GetSignalingChannelEndpoint (viewer role) + Query Parameters: Channel ARN as X-Amz-ChannelARN & Client Id as X-Amz-ClientId
42 | * Additional info
43 | *
44 | * Viewer URL example: {@literal wss://v-a1b2c3d4.kinesisvideo.us-west-2.amazonaws.com?X-Amz-ChannelARN=arn:aws:kinesisvideo:us-west-2:123456789012:channel/demo-channel/1234567890123&X-Amz-ClientId=d7d1c6e2-9cb0-4d61-bea9-ecb3d3816557}
45 | *
46 | * Note: The Signaling Channel Endpoints are different depending on the role (master/viewer) specified in GetSignalingChannelEndpoint API call.
47 | * Additional info
48 | * @param accessKey AWS Access Key Id.
49 | * @param secretKey AWS Secret Key.
50 | * @param sessionToken AWS Session Token, if applicable. Otherwise, can be {@code null} or an empty String ({@code ""}).
51 | * @param wssUri Same as URL to sign, excluding query parameters.
52 | * @param region AWS region. Example: us-west-2.
53 | * @param dateMilli Date at which this request to be signed. Milliseconds since epoch.
54 | * @return Presigned WebSocket URL you can use to connect to Kinesis Video Signaling.
55 | * @see Kinesis Video Streams WebRTC Websocket APIs
56 | */
57 | public static URI sign(final URI uri, final String accessKey, final String secretKey,
58 | final String sessionToken, final URI wssUri, final String region,
59 | final long dateMilli) {
60 | // Step 1. Create canonical request.
61 | final String amzDate = getTimeStamp(dateMilli);
62 | final String datestamp = getDateStamp(dateMilli);
63 | final Map queryParamsMap = buildQueryParamsMap(uri, accessKey, sessionToken, region, amzDate, datestamp);
64 | final String canonicalQuerystring = getCanonicalizedQueryString(queryParamsMap);
65 | final String canonicalRequest = getCanonicalRequest(uri, canonicalQuerystring);
66 |
67 | // Step 2. Construct StringToSign.
68 | final String stringToSign = signString(amzDate, createCredentialScope(region, datestamp), canonicalRequest);
69 |
70 | // Step 3. Calculate the signature.
71 | final byte[] signatureKey = getSignatureKey(secretKey, datestamp, region, AwsV4SignerConstants.SERVICE);
72 | final String signature = BinaryUtils.toHex(hmacSha256(stringToSign, signatureKey));
73 |
74 | // Step 4. Combine steps 1 and 3 to form the final URL.
75 | final String signedCanonicalQueryString = canonicalQuerystring + "&" + AwsV4SignerConstants.X_AMZ_SIGNATURE + "=" + signature;
76 |
77 | return URI.create(wssUri.getScheme() + "://" + wssUri.getHost() + "/?" + getCanonicalUri(uri).substring(1) + signedCanonicalQueryString);
78 | }
79 |
80 | /**
81 | * Same as {@link #sign(URI, String, String, String, URI, String, long)}, except the {@code wssUri}
82 | * parameter is extracted from the {@code uri} parameter and not passed in.
83 | */
84 | public static URI sign(final URI uri, final String accessKey, final String secretKey,
85 | final String sessionToken, final String region, final long dateMillis) {
86 | final URI wssUri = URI.create("wss://" + uri.getHost());
87 | return sign(uri, accessKey, secretKey, sessionToken, wssUri, region, dateMillis);
88 | }
89 |
90 | /**
91 | * Return a map of all of the query parameters as key-value pairs. The values will be
92 | * {@link #urlEncode(String)}'d. Note: The query parameters in this map may not be in
93 | * sorted order.
94 | *
95 | * The query parameters that are included in this map are:
96 | *
97 | * - {@value AwsV4SignerConstants#X_AMZ_ALGORITHM}
98 | * - {@value AwsV4SignerConstants#X_AMZ_CREDENTIAL}
99 | * - {@value AwsV4SignerConstants#X_AMZ_DATE}
100 | * - {@value AwsV4SignerConstants#X_AMZ_EXPIRES}
101 | * - {@value AwsV4SignerConstants#X_AMZ_SIGNED_HEADERS}
102 | * - {@value AwsV4SignerConstants#X_AMZ_SECURITY_TOKEN}, if the AWS Session Token is specified.
103 | * - And, the query parameters passed through {@code uri}.
104 | *
105 | *
106 | * @param uri URL to sign.
107 | * @param accessKey AWS Access Key Id.
108 | * @param sessionToken AWS Session Token. Can be null or an empty string if non-temporary credentials are used.
109 | * @param region AWS region. Example: us-west-2.
110 | * @param amzDate The result of {@link #getTimeStamp(long)}.
111 | * @param datestamp The result of {@link #getDateStamp(long)}.
112 | * @return Map of the query parameters to be included.
113 | * @see Authenticating Requests: Using Query Parameters (AWS Signature Version 4)
114 | */
115 | static Map buildQueryParamsMap(final URI uri,
116 | final String accessKey,
117 | final String sessionToken,
118 | final String region,
119 | final String amzDate,
120 | final String datestamp) {
121 | final ImmutableMap.Builder queryParamsBuilder = ImmutableMap.builder()
122 | .put(AwsV4SignerConstants.X_AMZ_ALGORITHM, AwsV4SignerConstants.ALGORITHM_AWS4_HMAC_SHA_256)
123 | .put(AwsV4SignerConstants.X_AMZ_CREDENTIAL, urlEncode(accessKey + "/" + createCredentialScope(region, datestamp)))
124 | .put(AwsV4SignerConstants.X_AMZ_DATE, amzDate)
125 |
126 | // The SigV4 signer has a maximum time limit of five minutes.
127 | // Once a connection is established, peers exchange signaling messages,
128 | // and the P2P connection is successful, the media P2P session
129 | // can continue for longer period of time.
130 | .put(AwsV4SignerConstants.X_AMZ_EXPIRES, "299")
131 | .put(AwsV4SignerConstants.X_AMZ_SIGNED_HEADERS, AwsV4SignerConstants.SIGNED_HEADERS);
132 |
133 | if (isNotEmpty(sessionToken)) {
134 | queryParamsBuilder.put(AwsV4SignerConstants.X_AMZ_SECURITY_TOKEN, urlEncode(sessionToken));
135 | }
136 |
137 | // Add the query parameters included in the uri.
138 | // Note: query parameters follow the format: key1=val1&key2=val2&key3=val3
139 | if (isNotEmpty(uri.getQuery())) {
140 | final String[] params = uri.getQuery().split("&");
141 | for (final String param : params) {
142 | final int index = param.indexOf('=');
143 | if (index > 0) {
144 | final String paramKey = param.substring(0, index);
145 | final String paramValue = urlEncode(param.substring(index + 1));
146 | queryParamsBuilder.put(paramKey, paramValue);
147 | }
148 | }
149 | }
150 | return queryParamsBuilder.build();
151 | }
152 |
153 | static String getCanonicalizedQueryString(final Map queryParamsMap) {
154 | final List queryKeys = new ArrayList<>(queryParamsMap.keySet());
155 | Collections.sort(queryKeys);
156 |
157 | final StringBuilder builder = new StringBuilder();
158 |
159 | for (int i = 0; i < queryKeys.size(); i++) {
160 | builder.append(queryKeys.get(i)).append("=").append(queryParamsMap.get(queryKeys.get(i)));
161 | if (queryKeys.size() - 1 > i) {
162 | builder.append("&");
163 | }
164 | }
165 |
166 | return builder.toString();
167 | }
168 |
169 | /**
170 | * Create and return the credential scope, which belongs in the X-Amz-Credential query parameter,
171 | * except for the access-key-id, and the slash that follows.
172 | *
173 | * The format of the full scope is as follows:
174 | * {@code ///kinesisvideo/aws4_request}
175 | *
176 | * @param region AWS Region. For example, us-west-2.
177 | * @param datestamp The datestamp in "yyyyMMdd" format. For example, "20160801".
178 | * @return The scope, except for the access-key-id and the slash that follows.
179 | */
180 | static String createCredentialScope(final String region, final String datestamp) {
181 | return new StringJoiner("/")
182 | .add(datestamp)
183 | .add(region)
184 | .add(AwsV4SignerConstants.SERVICE)
185 | .add(AwsV4SignerConstants.AWS4_REQUEST_TYPE)
186 | .toString();
187 | }
188 |
189 | /**
190 | * Constructs and returns the canonical request.
191 | *
192 | * An example canonical request looks like the following:
193 | *
194 | * GET
195 | * /
196 | * X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-ChannelARN=arn%3Aaws%3Akinesisvideo%3Aus-west-2%3A123456789012%3Achannel%2Fdemo-channel%2F1234567890123&X-Amz-ClientId=d7d1c6e2-9cb0-4d61-bea9-ecb3d3816557&X-Amz-Credential=AKIAIOSFODNN7EXAMPLE%2F20230718%2Fus-west-2%2Fkinesisvideo%2Faws4_request&X-Amz-Date=20230718T191301Z&X-Amz-Expires=299&X-Amz-SignedHeaders=host
197 | * host:v-1a2b3c4d.kinesisvideo.us-west-2.amazonaws.com
198 | *
199 | * host
200 | * e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
201 | *
202 | *
203 | * The format of the canonical request are as follows:
204 | *
205 | * - {@code HTTP method + "\n"} - With presigned URL's, it's always {@value AwsV4SignerConstants#METHOD}.
206 | * - {@code Canonical URI + "\n"} - Resource. In our case, it's always "/".
207 | * - {@code Canonical Query String + "\n"} - Sorted list of query parameters (and their values), excluding X-Amz-Signature. In our case: X-Amz-Algorithm, X-Amz-ChannelARN, X-Amz-ClientId (if viewer), X-Amz-Credential, X-Amz-Date, X-Amz-Expires.
208 | * - {@code Canonical Headers + "\n"} - In our case, we only have the required HTTP {@code host} header.
209 | * - {@code Signed Headers + "\n"} - Which headers, from the canonical headers, in alphabetical order.
210 | * - {@code Hashed Payload} - In our case, it's always the SHA-256 checksum of an empty string.
211 | *
212 | *
213 | * @param uri The URL to sign. For example, {@code wss://v-a1b2c3d4.kinesisvideo.us-west-2.amazonaws.com?
214 | * X-Amz-ChannelARN=arn:aws:kinesisvideo:us-west-2:123456789012:channel/demo-channel/1234567890123&X-Amz-ClientId=d7d1c6e2-9cb0-4d61-bea9-ecb3d3816557}.
215 | * @param canonicalQuerystring The Canonical Query String to use in the Canonical Request. Sorted list of query
216 | * parameters (and their values), excluding X-Amz-Signature, already URL-encoded.
217 | * @return The fully-constructed canonical request.
218 | * @see URL encoding
219 | * @see Canonical request specification
220 | */
221 | static String getCanonicalRequest(final URI uri, final String canonicalQuerystring) {
222 | final String payloadHash = sha256().hashString(EMPTY, UTF_8).toString();
223 | final String canonicalUri = getCanonicalUri(uri);
224 | final String canonicalHeaders = "host:" + uri.getHost() + AwsV4SignerConstants.NEW_LINE_DELIMITER;
225 |
226 | return new StringJoiner(AwsV4SignerConstants.NEW_LINE_DELIMITER)
227 | .add(AwsV4SignerConstants.METHOD)
228 | .add(canonicalUri)
229 | .add(canonicalQuerystring)
230 | .add(canonicalHeaders)
231 | .add(AwsV4SignerConstants.SIGNED_HEADERS)
232 | .add(payloadHash)
233 | .toString();
234 | }
235 |
236 | static String getCanonicalUri(final URI uri) {
237 | return Optional.of(uri.getPath())
238 | .filter(s -> !isEmpty(s))
239 | .orElse("/");
240 | }
241 |
242 | /**
243 | * Returns the following string. Each line (except the last one) is followed by a newline character.
244 | *
245 | * Algorithm
246 | * RequestDateTime
247 | * CredentialScope
248 | * HashedCanonicalRequest
249 | *
250 | *
251 | * Here is an explanation of each line.
252 | *
253 | * - Algorithm - For SHA-256, we use AWS4-HMAC-SHA256.
254 | * - RequestDateTime - Timestamp from {@link #getTimeStamp(long)}.
255 | * - CredentialScope - Scope from {@link #createCredentialScope(String, String)}.
256 | * - HashedCanonicalRequest - Hash of {@link #getCanonicalRequest(URI, String)}.
257 | * Since we use SHA-256, this is the SHA-256 digest of the canonical request.
258 | *
259 | *
260 | * An example of a string to sign looks like the following:
261 | *
262 | * AWS4-HMAC-SHA256
263 | * 20150830T123600Z
264 | * AKIDEXAMPLE/20150830/us-west-2/kinesisvideo/aws4_request
265 | * 816cd5b414d056048ba4f7c5386d6e0533120fb1fcfa93762cf0fc39e2cf19e0
266 | *
267 | *
268 | * @param amzDate The result of {@link #getTimeStamp(long)}.
269 | * @param credentialScope the result of {@link #createCredentialScope(String, String)}.
270 | * @param canonicalRequest the result of {@link #getCanonicalRequest(URI, String)}.
271 | * @return The string to sign.
272 | * @see String to sign
273 | */
274 | static String signString(final String amzDate, final String credentialScope, final String canonicalRequest) {
275 | return new StringJoiner(AwsV4SignerConstants.NEW_LINE_DELIMITER)
276 | .add(AwsV4SignerConstants.ALGORITHM_AWS4_HMAC_SHA_256)
277 | .add(amzDate)
278 | .add(credentialScope)
279 | .add(sha256().hashString(canonicalRequest, UTF_8).toString())
280 | .toString();
281 | }
282 |
283 | static String urlEncode(final String str) {
284 | try {
285 | return URLEncoder.encode(str, UTF_8.name());
286 | } catch (final Exception e) {
287 | throw new IllegalArgumentException(e.getMessage(), e);
288 | }
289 | }
290 |
291 | // https://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-java
292 | static byte[] hmacSha256(final String data, final byte[] key) {
293 | final String algorithm = "HmacSHA256";
294 | final Mac mac;
295 | try {
296 | mac = Mac.getInstance(algorithm);
297 | mac.init(new SecretKeySpec(key, algorithm));
298 | return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
299 | } catch (final Exception e) {
300 | throw new IllegalArgumentException(e.getMessage(), e);
301 | }
302 | }
303 |
304 | /**
305 | * Calculate and return the signature key. Note: the returned signature must be converted from
306 | * binary to hexadecimal representation (lowercase letters).
307 | *
308 | * The formula is as follows:
309 | *
310 | * kDate = hash("AWS4" + Key, Date)
311 | * kRegion = hash(kDate, Region)
312 | * kService = hash(kRegion, ServiceName)
313 | * kSigning = hash(kService, "aws4_request")
314 | * ksignature = hash(kSigning, string-to-sign)
315 | *
316 | *
317 | * @param key AWS secret access key.
318 | * @param dateStamp Date used in the credential scope. Format: yyyyMMdd.
319 | * @param regionName AWS region. Example: us-west-2.
320 | * @param serviceName The name of the service. Should be {@code kinesisvideo}.
321 | * @return {@code ksignature}, as specified above.
322 | * @see Calculate signature
323 | */
324 | static byte[] getSignatureKey(
325 | final String key,
326 | final String dateStamp,
327 | final String regionName,
328 | final String serviceName) {
329 | final byte[] kSecret = ("AWS4" + key).getBytes(StandardCharsets.UTF_8);
330 | final byte[] kDate = hmacSha256(dateStamp, kSecret);
331 | final byte[] kRegion = hmacSha256(regionName, kDate);
332 | final byte[] kService = hmacSha256(serviceName, kRegion);
333 | return hmacSha256(AwsV4SignerConstants.AWS4_REQUEST_TYPE, kService);
334 | }
335 |
336 | /**
337 | * Returns the date and time, formatted to follow the ISO 8601 standard,
338 | * which is the "yyyyMMddTHHmmssZ" format.
339 | *
340 | * For example if the date and time was "08/01/2016 15:32:41.982-700"
341 | * then it must first be converted to UTC (Coordinated Universal Time)
342 | * and then submitted as "20160801T223241Z".
343 | *
344 | * @param dateMilli The milliseconds since epoch at which this request is to be signed at.
345 | * Must be the same as the one passed to {@link #getDateStamp(long)} to avoid
346 | * signing issues at midnight UTC.
347 | * @return The date string, formatted to the ISO 8601 standard.
348 | */
349 | static String getTimeStamp(final long dateMilli) {
350 | return DateUtils.format(AwsV4SignerConstants.TIME_PATTERN, new Date(dateMilli));
351 | }
352 |
353 | /**
354 | * Returns the date in yyyyMMdd format.
355 | *
356 | * For example if the date and time was "08/01/2016 15:32:41.982-700"
357 | * then it must first be converted to UTC (Coordinated Universal Time)
358 | * and "20160801" will be returned.
359 | *
360 | * @param dateMilli The milliseconds since epoch at which this request is to be signed at.
361 | * Must be the same as the one passed to {@link #getTimeStamp(long)} to avoid
362 | * signing issues at midnight UTC.
363 | * @return The date string, without the current time.
364 | */
365 | static String getDateStamp(final long dateMilli) {
366 | return DateUtils.format(AwsV4SignerConstants.DATE_PATTERN, new Date(dateMilli));
367 | }
368 | }
--------------------------------------------------------------------------------
/app/src/main/java/com/amazonaws/kinesisvideo/demoapp/fragment/StreamWebRtcConfigurationFragment.java:
--------------------------------------------------------------------------------
1 | package com.amazonaws.kinesisvideo.demoapp.fragment;
2 |
3 | import android.Manifest;
4 | import com.amazonaws.kinesisvideo.demoapp.BuildConfig;
5 | import android.content.Intent;
6 | import android.content.pm.PackageManager;
7 | import android.os.AsyncTask;
8 | import android.os.Bundle;
9 | import android.util.Log;
10 | import android.util.SparseBooleanArray;
11 | import android.view.LayoutInflater;
12 | import android.view.View;
13 | import android.view.ViewGroup;
14 | import android.widget.ArrayAdapter;
15 | import android.widget.Button;
16 | import android.widget.CheckBox;
17 | import android.widget.CheckedTextView;
18 | import android.widget.EditText;
19 | import android.widget.ListView;
20 | import android.widget.Spinner;
21 |
22 | import androidx.annotation.NonNull;
23 | import androidx.annotation.Nullable;
24 | import androidx.appcompat.app.AlertDialog;
25 | import androidx.core.app.ActivityCompat;
26 | import androidx.core.content.ContextCompat;
27 | import androidx.fragment.app.Fragment;
28 | import android.content.Context;
29 |
30 | import com.amazonaws.kinesisvideo.demoapp.KinesisVideoWebRtcDemoApp;
31 | import com.amazonaws.kinesisvideo.demoapp.R;
32 | import com.amazonaws.kinesisvideo.demoapp.activity.SimpleNavActivity;
33 | import com.amazonaws.kinesisvideo.demoapp.activity.WebRtcActivity;
34 | import com.amazonaws.regions.Region;
35 | import com.amazonaws.services.kinesisvideo.AWSKinesisVideoClient;
36 | import com.amazonaws.services.kinesisvideo.model.ChannelRole;
37 | import com.amazonaws.services.kinesisvideo.model.CreateSignalingChannelRequest;
38 | import com.amazonaws.services.kinesisvideo.model.CreateSignalingChannelResult;
39 | import com.amazonaws.services.kinesisvideo.model.DescribeMediaStorageConfigurationRequest;
40 | import com.amazonaws.services.kinesisvideo.model.DescribeMediaStorageConfigurationResult;
41 | import com.amazonaws.services.kinesisvideo.model.DescribeSignalingChannelRequest;
42 | import com.amazonaws.services.kinesisvideo.model.DescribeSignalingChannelResult;
43 | import com.amazonaws.services.kinesisvideo.model.GetSignalingChannelEndpointRequest;
44 | import com.amazonaws.services.kinesisvideo.model.GetSignalingChannelEndpointResult;
45 | import com.amazonaws.services.kinesisvideo.model.ResourceEndpointListItem;
46 | import com.amazonaws.services.kinesisvideo.model.ResourceNotFoundException;
47 | import com.amazonaws.services.kinesisvideo.model.SingleMasterChannelEndpointConfiguration;
48 | import com.amazonaws.services.kinesisvideosignaling.AWSKinesisVideoSignalingClient;
49 | import com.amazonaws.services.kinesisvideosignaling.model.GetIceServerConfigRequest;
50 | import com.amazonaws.services.kinesisvideosignaling.model.GetIceServerConfigResult;
51 | import com.amazonaws.services.kinesisvideosignaling.model.IceServer;
52 |
53 |
54 | import java.lang.ref.WeakReference;
55 | import java.util.ArrayList;
56 | import java.util.Arrays;
57 | import java.util.List;
58 |
59 | public class StreamWebRtcConfigurationFragment extends Fragment {
60 | private static final String TAG = StreamWebRtcConfigurationFragment.class.getSimpleName();
61 |
62 | private static final String KEY_CHANNEL_NAME = "channelName";
63 | public static final String KEY_CLIENT_ID = "clientId";
64 | public static final String KEY_REGION = "region";
65 | public static final String KEY_CHANNEL_ARN = "channelArn";
66 | public static final String KEY_STREAM_ARN = "streamArn";
67 | public static final String KEY_WSS_ENDPOINT = "wssEndpoint";
68 | public static final String KEY_WEBRTC_ENDPOINT = "webrtcEndpoint";
69 | public static final String KEY_IS_MASTER = "isMaster";
70 | public static final String KEY_ICE_SERVER_USER_NAME = "iceServerUserName";
71 | public static final String KEY_ICE_SERVER_PASSWORD = "iceServerPassword";
72 | public static final String KEY_ICE_SERVER_TTL = "iceServerTTL";
73 | public static final String KEY_ICE_SERVER_URI = "iceServerUri";
74 | public static final String KEY_CAMERA_FRONT_FACING = "cameraFrontFacing";
75 |
76 | public static final String KEY_SEND_VIDEO = "sendVideo";
77 | public static final String KEY_SEND_AUDIO = "sendAudio";
78 |
79 | private static final String[] WEBRTC_OPTIONS = {
80 | "Send Video",
81 | "Send Audio",
82 | };
83 |
84 | private static final String[] KEY_OF_OPTIONS = {
85 | KEY_SEND_VIDEO,
86 | KEY_SEND_AUDIO,
87 | };
88 |
89 |
90 | private EditText mChannelName;
91 | private EditText mClientId;
92 | private EditText mRegion;
93 | private Spinner mCameras;
94 | private CheckBox mIngestMedia;
95 | private final List mEndpointList = new ArrayList<>();
96 | private final List mIceServerList = new ArrayList<>();
97 | private String mChannelArn = null;
98 | private String mStreamArn = null;
99 | private ListView mOptions;
100 |
101 | private SimpleNavActivity navActivity;
102 |
103 | public static StreamWebRtcConfigurationFragment newInstance(SimpleNavActivity navActivity) {
104 | StreamWebRtcConfigurationFragment s = new StreamWebRtcConfigurationFragment();
105 | s.navActivity = navActivity;
106 | return s;
107 | }
108 |
109 | @Override
110 | public View onCreateView(final LayoutInflater inflater,
111 | final ViewGroup container,
112 | final Bundle savedInstanceState) {
113 | if (getActivity() != null) {
114 | if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
115 | || ContextCompat.checkSelfPermission(this.getActivity(), Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
116 | ActivityCompat.requestPermissions(this.getActivity(), new String[]{Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO}, 9393);
117 | }
118 |
119 | getActivity().setTitle(getActivity().getString(R.string.title_fragment_channel));
120 | }
121 |
122 | return inflater.inflate(R.layout.fragment_stream_webrtc_configuration, container, false);
123 | }
124 |
125 | @Override
126 | public void onViewCreated(final View view, Bundle savedInstanceState) {
127 | Button mStartMasterButton = view.findViewById(R.id.start_master);
128 | mStartMasterButton.setOnClickListener(startMasterActivityWhenClicked());
129 | Button mStartViewerButton = view.findViewById(R.id.start_viewer);
130 | mStartViewerButton.setOnClickListener(startViewerActivityWhenClicked());
131 |
132 | mChannelName = view.findViewById(R.id.channel_name);
133 | mClientId = view.findViewById(R.id.client_id);
134 | mRegion = view.findViewById(R.id.region);
135 | mIngestMedia = view.findViewById(R.id.ingest_media);
136 | setRegionFromCognito();
137 |
138 | mOptions = view.findViewById(R.id.webrtc_options);
139 | mOptions.setAdapter(new ArrayAdapter(getActivity(), android.R.layout.simple_list_item_multiple_choice, WEBRTC_OPTIONS) {
140 | @NonNull
141 | @Override
142 | public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
143 | if (convertView == null) {
144 | View v = getLayoutInflater().inflate(android.R.layout.simple_list_item_multiple_choice, null);
145 |
146 | final CheckedTextView ctv = v.findViewById(android.R.id.text1);
147 | ctv.setText(WEBRTC_OPTIONS[position]);
148 |
149 | // Send video is now optional
150 | return v;
151 | }
152 |
153 | return convertView;
154 | }
155 | });
156 | mOptions.setItemsCanFocus(false);
157 | mOptions.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
158 | mOptions.setItemChecked(0, true);
159 |
160 | mCameras = view.findViewById(R.id.camera_spinner);
161 |
162 | final List cameraList = Arrays.asList("Front Camera", "Back Camera");
163 |
164 | if (getContext() != null) {
165 | mCameras.setAdapter(new ArrayAdapter<>(getContext(),
166 | android.R.layout.simple_spinner_dropdown_item,
167 | cameraList));
168 | }
169 | }
170 |
171 | private void setRegionFromCognito() {
172 | String region = KinesisVideoWebRtcDemoApp.getRegion();
173 | if (region != null) {
174 | mRegion.setText(region);
175 | }
176 | }
177 |
178 |
179 |
180 | private View.OnClickListener startMasterActivityWhenClicked() {
181 | return new View.OnClickListener() {
182 | @Override
183 | public void onClick(final View view) {
184 | startMasterActivity();
185 | }
186 | };
187 | }
188 |
189 | private void startMasterActivity() {
190 | final SparseBooleanArray checked = mOptions.getCheckedItemPositions();
191 |
192 | if (mIngestMedia.isChecked()) {
193 | // Check that both "Send Audio" and "Send Video" boxes are enabled for ingest media
194 | for (int i = 0; i < mOptions.getCount(); i++) {
195 | if (!checked.get(i)) {
196 | new AlertDialog.Builder(getActivity())
197 | .setPositiveButton("OK", null)
198 | .setMessage("Audio and video must be sent to ingest media!")
199 | .create()
200 | .show();
201 | return;
202 | }
203 | }
204 | }
205 |
206 | if (!updateSignalingChannelInfo(mRegion.getText().toString(),
207 | mChannelName.getText().toString(),
208 | ChannelRole.MASTER)) {
209 | return;
210 | }
211 |
212 | if (mChannelArn != null) {
213 | Bundle extras = setExtras(true);
214 | Intent intent = new Intent(getActivity(), WebRtcActivity.class);
215 | intent.putExtras(extras);
216 | startActivity(intent);
217 | }
218 | }
219 |
220 | private View.OnClickListener startViewerActivityWhenClicked() {
221 | return new View.OnClickListener() {
222 | @Override
223 | public void onClick(final View view) {
224 | startViewerActivity();
225 | }
226 | };
227 | }
228 |
229 | private void startViewerActivity() {
230 | Log.i(TAG, "Start Viewer button clicked - beginning viewer activity setup");
231 | final SparseBooleanArray checked = mOptions.getCheckedItemPositions();
232 |
233 | // Check if Ingest Media is checked with Send Video
234 | if (mIngestMedia.isChecked() && checked.get(0)) {
235 | new AlertDialog.Builder(getActivity())
236 | .setPositiveButton("OK", null)
237 | .setMessage("Multi-viewer participant is allowed to send only audio; please deselect video for multiviewer option")
238 | .create()
239 | .show();
240 | return;
241 | }
242 |
243 | if (!updateSignalingChannelInfo(mRegion.getText().toString(),
244 | mChannelName.getText().toString(),
245 | ChannelRole.VIEWER)) {
246 | return;
247 | }
248 |
249 | if (mChannelArn != null) {
250 | Bundle extras = setExtras(false);
251 | Intent intent = new Intent(getActivity(), WebRtcActivity.class);
252 | intent.putExtras(extras);
253 | startActivity(intent);
254 | }
255 | }
256 |
257 | private Bundle setExtras(boolean isMaster) {
258 | final Bundle extras = new Bundle();
259 | final String channelName = mChannelName.getText().toString();
260 | final String clientId = mClientId.getText().toString();
261 | final String region = mRegion.getText().toString();
262 |
263 | extras.putString(KEY_CHANNEL_NAME, channelName);
264 | extras.putString(KEY_CLIENT_ID, clientId);
265 | extras.putString(KEY_REGION, region);
266 | extras.putString(KEY_REGION, region);
267 | extras.putString(KEY_CHANNEL_ARN, mChannelArn);
268 | extras.putString(KEY_STREAM_ARN, mStreamArn);
269 | extras.putBoolean(KEY_IS_MASTER, isMaster);
270 |
271 | if (!mIceServerList.isEmpty()) {
272 | ArrayList userNames = new ArrayList<>(mIceServerList.size());
273 | ArrayList passwords = new ArrayList<>(mIceServerList.size());
274 | ArrayList ttls = new ArrayList<>(mIceServerList.size());
275 | ArrayList> urisList = new ArrayList<>();
276 | for (final IceServer iceServer : mIceServerList) {
277 | userNames.add(iceServer.getUsername());
278 | passwords.add(iceServer.getPassword());
279 | ttls.add(iceServer.getTtl());
280 | urisList.add(iceServer.getUris());
281 | }
282 | extras.putStringArrayList(KEY_ICE_SERVER_USER_NAME, userNames);
283 | extras.putStringArrayList(KEY_ICE_SERVER_PASSWORD, passwords);
284 | extras.putIntegerArrayList(KEY_ICE_SERVER_TTL, ttls);
285 | extras.putSerializable(KEY_ICE_SERVER_URI, urisList);
286 | } else {
287 | extras.putStringArrayList(KEY_ICE_SERVER_USER_NAME, null);
288 | extras.putStringArrayList(KEY_ICE_SERVER_PASSWORD, null);
289 | extras.putIntegerArrayList(KEY_ICE_SERVER_TTL, null);
290 | extras.putSerializable(KEY_ICE_SERVER_URI, null);
291 | }
292 |
293 | for (ResourceEndpointListItem endpoint : mEndpointList) {
294 | if (endpoint.getProtocol().equals("WSS")) {
295 | extras.putString(KEY_WSS_ENDPOINT, endpoint.getResourceEndpoint());
296 | } else if (endpoint.getProtocol().equals("WEBRTC")) {
297 | extras.putString(KEY_WEBRTC_ENDPOINT, endpoint.getResourceEndpoint());
298 | }
299 | }
300 |
301 | final SparseBooleanArray checked = mOptions.getCheckedItemPositions();
302 | for (int i = 0; i < mOptions.getCount(); i++) {
303 | extras.putBoolean(KEY_OF_OPTIONS[i], checked.get(i));
304 | }
305 |
306 | extras.putBoolean(KEY_CAMERA_FRONT_FACING, mCameras.getSelectedItem().equals("Front Camera"));
307 |
308 | return extras;
309 | }
310 |
311 | private AWSKinesisVideoClient getAwsKinesisVideoClient(final String region) {
312 | final AWSKinesisVideoClient awsKinesisVideoClient = new AWSKinesisVideoClient(
313 | KinesisVideoWebRtcDemoApp.getCredentialsProvider().getCredentials());
314 | awsKinesisVideoClient.setRegion(Region.getRegion(region));
315 | awsKinesisVideoClient.setSignerRegionOverride(region);
316 | awsKinesisVideoClient.setServiceNameIntern("kinesisvideo");
317 | try {
318 | String customEndpoint = BuildConfig.CONTROL_PLANE_URI;
319 | if (customEndpoint != null && !customEndpoint.isEmpty() && !"null".equals(customEndpoint)) {
320 | awsKinesisVideoClient.setEndpoint(customEndpoint);
321 | }
322 | } catch (Exception e) {
323 | // CONTROL_PLANE_URI not defined in .env
324 | }
325 |
326 | return awsKinesisVideoClient;
327 | }
328 |
329 | private AWSKinesisVideoSignalingClient getAwsKinesisVideoSignalingClient(final String region, final String endpoint) {
330 | final AWSKinesisVideoSignalingClient client = new AWSKinesisVideoSignalingClient(
331 | KinesisVideoWebRtcDemoApp.getCredentialsProvider().getCredentials());
332 | client.setRegion(Region.getRegion(region));
333 | client.setSignerRegionOverride(region);
334 | client.setServiceNameIntern("kinesisvideo");
335 | client.setEndpoint(endpoint);
336 | return client;
337 | }
338 |
339 | /**
340 | * Fetches info needed to connect to the Amazon Kinesis Video Streams Signaling channel.
341 | *
342 | * @param region The region the Signaling channel is located in.
343 | * @param channelName The name of the Amazon Kinesis Video Streams Signaling channel.
344 | * @param role The signaling channel role (master or viewer).
345 | * @return {@code true} on success. {@code false} if unsuccessful.
346 | */
347 | private boolean updateSignalingChannelInfo(final String region, final String channelName, final ChannelRole role) {
348 | mEndpointList.clear();
349 | mIceServerList.clear();
350 | mChannelArn = null;
351 | final UpdateSignalingChannelInfoTask task = new UpdateSignalingChannelInfoTask(this);
352 |
353 | String errorMessage = null;
354 | try {
355 | errorMessage = task.execute(region, channelName, role).get();
356 | } catch (Exception e) {
357 | Log.e(TAG, "Failed to wait for response of UpdateSignalingChannelInfoTask", e);
358 | }
359 |
360 | if (errorMessage != null) {
361 | Log.e(TAG, "updateSignalingChannelInfo() encountered an error: " + errorMessage);
362 | // Show error to user for debugging
363 | final String finalErrorMessage = errorMessage;
364 | if (getActivity() != null) {
365 | getActivity().runOnUiThread(() -> {
366 | new AlertDialog.Builder(getContext())
367 | .setTitle("Connection Error")
368 | .setMessage(finalErrorMessage)
369 | .setPositiveButton("OK", null)
370 | .show();
371 | });
372 | }
373 | }
374 | return errorMessage == null;
375 | }
376 |
377 | /**
378 | * Makes backend calls to KVS in order to obtain info needed to start the WebRTC session.
379 | *
380 | * The task returns {@code null} upon success, otherwise, it returns an error message.
381 | */
382 | static class UpdateSignalingChannelInfoTask extends AsyncTask {
383 | final WeakReference mFragment;
384 |
385 | UpdateSignalingChannelInfoTask(final StreamWebRtcConfigurationFragment fragment) {
386 | mFragment = new WeakReference<>(fragment);
387 | }
388 |
389 | @Override
390 | protected String doInBackground(final Object... objects) {
391 | final String region = (String) objects[0];
392 | final String channelName = (String) objects[1];
393 | final ChannelRole role = (ChannelRole) objects[2];
394 |
395 | // Step 1. Create Kinesis Video Client
396 | final AWSKinesisVideoClient awsKinesisVideoClient;
397 | try {
398 | awsKinesisVideoClient = mFragment.get().getAwsKinesisVideoClient(region);
399 | } catch (Exception e) {
400 | return "Create client failed with " + e.getLocalizedMessage();
401 | }
402 |
403 | // Step 2. Use the Kinesis Video Client to call DescribeSignalingChannel API.
404 | // If that fails with ResourceNotFoundException, the channel does not exist.
405 | // If we are connecting as Master, if it doesn't exist, we attempt to create
406 | // it by calling CreateSignalingChannel API.
407 | try {
408 | final DescribeSignalingChannelResult describeSignalingChannelResult = awsKinesisVideoClient.describeSignalingChannel(
409 | new DescribeSignalingChannelRequest()
410 | .withChannelName(channelName));
411 |
412 | Log.i(TAG, "Channel ARN is " + describeSignalingChannelResult.getChannelInfo().getChannelARN());
413 | mFragment.get().mChannelArn = describeSignalingChannelResult.getChannelInfo().getChannelARN();
414 | } catch (final ResourceNotFoundException e) {
415 | if (role.equals(ChannelRole.MASTER)) {
416 | try {
417 | CreateSignalingChannelResult createSignalingChannelResult = awsKinesisVideoClient.createSignalingChannel(
418 | new CreateSignalingChannelRequest()
419 | .withChannelName(channelName));
420 |
421 | mFragment.get().mChannelArn = createSignalingChannelResult.getChannelARN();
422 | } catch (Exception ex) {
423 | return "Create Signaling Channel failed with Exception " + ex.getLocalizedMessage();
424 | }
425 | } else {
426 | return "Signaling Channel " + channelName + " doesn't exist!";
427 | }
428 | } catch (Exception ex) {
429 | return "Describe Signaling Channel failed with Exception " + ex.getLocalizedMessage();
430 | }
431 |
432 | // Step 3. If we are ingesting media, we need to check if the Signaling Channel has a Kinesis Video
433 | // Stream configured to write media to. We can call the DescribeMediaStorageConfiguration API
434 | // to determine this.
435 | if (role == ChannelRole.MASTER && mFragment.get().mIngestMedia.isChecked()) {
436 | try {
437 | final DescribeMediaStorageConfigurationResult describeMediaStorageConfigurationResult = awsKinesisVideoClient.describeMediaStorageConfiguration(
438 | new DescribeMediaStorageConfigurationRequest()
439 | .withChannelARN(mFragment.get().mChannelArn));
440 |
441 | if (!"ENABLED".equalsIgnoreCase(describeMediaStorageConfigurationResult.getMediaStorageConfiguration().getStatus())) {
442 | Log.e(TAG, "Media storage is not enabled for this channel!");
443 | return "Media Storage is DISABLED for this channel!";
444 | }
445 | mFragment.get().mStreamArn = describeMediaStorageConfigurationResult.getMediaStorageConfiguration().getStreamARN();
446 | } catch (Exception ex) {
447 | return "Describe Media Storage Configuration failed with Exception " + ex.getLocalizedMessage();
448 | }
449 | }
450 |
451 | final String[] protocols;
452 | if (mFragment.get().mIngestMedia.isChecked()) {
453 | protocols = new String[]{"WSS", "HTTPS", "WEBRTC"};
454 | } else {
455 | protocols = new String[]{"WSS", "HTTPS"};
456 | }
457 |
458 | // Step 4. Use the Kinesis Video Client to call GetSignalingChannelEndpoint.
459 | // Each signaling channel is assigned an HTTPS and WSS endpoint to connect
460 | // to for data-plane operations, which we fetch using the GetSignalingChannelEndpoint API,
461 | // and a WEBRTC endpoint to for storage data-plane operations.
462 | // Attempting to obtain the WEBRTC endpoint if the signaling channel is not configured
463 | // will result in an InvalidArgumentException.
464 | try {
465 | final GetSignalingChannelEndpointResult getSignalingChannelEndpointResult = awsKinesisVideoClient.getSignalingChannelEndpoint(
466 | new GetSignalingChannelEndpointRequest()
467 | .withChannelARN(mFragment.get().mChannelArn)
468 | .withSingleMasterChannelEndpointConfiguration(
469 | new SingleMasterChannelEndpointConfiguration()
470 | .withProtocols(protocols)
471 | .withRole(role)));
472 |
473 | Log.i(TAG, "Endpoints " + getSignalingChannelEndpointResult.toString());
474 | mFragment.get().mEndpointList.addAll(getSignalingChannelEndpointResult.getResourceEndpointList());
475 | } catch (Exception e) {
476 | return "Get Signaling Endpoint failed with Exception " + e.getLocalizedMessage();
477 | }
478 |
479 | String dataEndpoint = null;
480 | for (ResourceEndpointListItem endpoint : mFragment.get().mEndpointList) {
481 | if (endpoint.getProtocol().equals("HTTPS")) {
482 | dataEndpoint = endpoint.getResourceEndpoint();
483 | }
484 | }
485 |
486 | // Step 5. Construct the Kinesis Video Signaling Client. The HTTPS endpoint from the
487 | // GetSignalingChannelEndpoint response above is used with this client. This
488 | // client is just used for getting ICE servers, not for actual signaling.
489 | // Step 6. Call GetIceServerConfig in order to obtain TURN ICE server info.
490 | // Note: the STUN endpoint will be `stun:stun.kinesisvideo.${region}.amazonaws.com:443`
491 | try {
492 | final AWSKinesisVideoSignalingClient awsKinesisVideoSignalingClient = mFragment.get().getAwsKinesisVideoSignalingClient(region, dataEndpoint);
493 | GetIceServerConfigResult getIceServerConfigResult = awsKinesisVideoSignalingClient.getIceServerConfig(
494 | new GetIceServerConfigRequest().withChannelARN(mFragment.get().mChannelArn).withClientId(role.name()));
495 | mFragment.get().mIceServerList.addAll(getIceServerConfigResult.getIceServerList());
496 | } catch (Exception e) {
497 | return "Get Ice Server Config failed with Exception " + e.getLocalizedMessage();
498 | }
499 |
500 | return null;
501 | }
502 |
503 | /**
504 | * Shows a Dialog box if any errors were returned in {@link #doInBackground(Object...)}.
505 | *
506 | * @param result This will be displayed in the Dialog box.
507 | */
508 | @Override
509 | protected void onPostExecute(final String result) {
510 | if (result != null) {
511 | new AlertDialog.Builder(mFragment.get().getContext())
512 | .setPositiveButton("OK", null)
513 | .setMessage(result)
514 | .create()
515 | .show();
516 | }
517 | }
518 | }
519 | }
--------------------------------------------------------------------------------