├── .gitignore
├── .gitmodules
├── patch
    ├── freertos_20200700_4e8219e0.patch
    └── AiaClientSDK_0deab3e0.patch
├── images
    └── apal_afr_integration_source_tree.png
├── CODE_OF_CONDUCT.md
├── NOTICE
├── ports
    ├── Button
    │   └── include
    │   │   └── button
    │   │       └── aia_button_config.h
    ├── Crypto
    │   ├── src
    │   │   └── aia_crypto_config.c
    │   └── include
    │   │   └── crypto
    │   │       └── aia_crypto_config.h
    ├── include
    │   ├── aia_config.h
    │   ├── aia_capabilities_config.h
    │   └── aia_application_config.h
    ├── Microphone
    │   └── include
    │   │   └── microphone
    │   │       └── aia_microphone_config.h
    ├── Memory
    │   └── include
    │   │   └── memory
    │   │       └── aia_memory_config.h
    ├── Clock
    │   ├── include
    │   │   └── clock
    │   │   │   └── aia_clock_config.h
    │   └── src
    │   │   └── aia_clock_config.c
    ├── Common
    │   └── include
    │   │   └── common
    │   │       └── aia_common_config.h
    ├── IoT
    │   ├── src
    │   │   └── aia_iot_config.c
    │   └── include
    │   │   └── iot
    │   │       └── aia_iot_config.h
    ├── LWA
    │   ├── src
    │   │   └── aia_lwa_config.c
    │   └── include
    │   │   └── lwa
    │   │       └── aia_lwa_config.h
    ├── Registration
    │   ├── include
    │   │   └── registration
    │   │   │   └── aia_registration_config.h
    │   └── src
    │   │   └── aia_registration_config.c
    ├── HTTP
    │   ├── include
    │   │   └── http
    │   │   │   └── aia_http_config.h
    │   └── src
    │   │   └── aia_http_config.c
    └── Storage
    │   ├── include
    │       └── storage
    │       │   └── aia_storage_config.h
    │   └── src
    │       └── aia_storage_config.c
├── demos
    └── aia
    │   ├── aia_sample_app.h
    │   ├── utils
    │       └── aiaportaudiomicrophone
    │       │   ├── include
    │       │       └── aiaportaudiomicrophone
    │       │       │   └── aia_portaudio_microphone.h
    │       │   └── source
    │       │       └── aia_portaudio_microphone.c
    │   ├── aia_sample_main.c
    │   └── aia_sample_app.c
├── CONTRIBUTING.md
├── CMakeLists.txt
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | external/AIAClientSDK
2 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "external/AIAClientSDK"]
2 | 	path = external/AIAClientSDK
3 | 	url = https://github.com/alexa/AIAClientSDK.git
4 | 


--------------------------------------------------------------------------------
/patch/freertos_20200700_4e8219e0.patch:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aws-samples/alexa-voice-service-integration-for-aws-iot-freertos-porting-kit/master/patch/freertos_20200700_4e8219e0.patch


--------------------------------------------------------------------------------
/images/apal_afr_integration_source_tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aws-samples/alexa-voice-service-integration-for-aws-iot-freertos-porting-kit/master/images/apal_afr_integration_source_tree.png


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | ## Code of Conduct
2 | This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
3 | For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
4 | opensource-codeofconduct@amazon.com with any additional questions or comments.
5 | 


--------------------------------------------------------------------------------
/NOTICE:
--------------------------------------------------------------------------------
 1 | AIA Client SDK FreeRTOS Porting
 2 | Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 | 
 4 | **********************
 5 | THIRD PARTY COMPONENTS
 6 | **********************
 7 | This software includes third party software subject to the following licensing:
 8 | - mbedTLS (external library, downloaded separately)  - Apache 2.0
 9 | - Amazon FreeRTOS (external library, downloaded separately) - MIT
10 | - AIA Device SDK (external library, downloaded separately) - PML
11 | - Portaudio (external library, downloaded separately) - MIT
12 | - Opus (external library, downloaded separately) - BSD


--------------------------------------------------------------------------------
/ports/Button/include/button/aia_button_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_BUTTON_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_BUTTON_CONFIG_H_
22 | 
23 | /** Optional flag to enable faster local stoppage of audio on pause and stop
24 |  * button presses. */
25 | #define AIA_BUTTON_LOCAL_STOP
26 | 
27 | #ifdef __cplusplus
28 | }
29 | #endif
30 | #endif /* ifndef AIA_BUTTON_CONFIG_H_ */
31 | 


--------------------------------------------------------------------------------
/ports/Crypto/src/aia_crypto_config.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_crypto_config.c
19 |  * @brief Implements platform-specific Crypto functions which are not inlined in
20 |  * @c aia_crypto_config.h.
21 |  */
22 | 
23 | #include <crypto/aia_crypto_config.h>
24 | 
25 | bool AiaCrypto_SetKey( const uint8_t* encryptKey, size_t encryptKeySize,
26 |                        const AiaEncryptionAlgorithm_t encryptAlgorithm )
27 | {
28 |     return AiaCryptoMbedtls_SetKey( encryptKey, encryptKeySize,
29 |                                     encryptAlgorithm );
30 | }
31 | 


--------------------------------------------------------------------------------
/ports/include/aia_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C"
20 | {
21 | #endif
22 | #define AIA_CONFIG_H_
23 | 
24 | /* The IoT config header */
25 | #include <iot_config.h>
26 | #include "threading_alt.h"
27 | 
28 | #include <button/aia_button_config.h>
29 | #include <crypto/aia_crypto_config.h>
30 | #include <http/aia_http_config.h>
31 | #include <iot/aia_iot_config.h>
32 | #include <lwa/aia_lwa_config.h>
33 | #include <memory/aia_memory_config.h>
34 | #include <microphone/aia_microphone_config.h>
35 | #include <registration/aia_registration_config.h>
36 | #include <storage/aia_storage_config.h>
37 | 
38 | #include <common/aia_common_config.h>
39 | 
40 | /* AIA Capabilities Config */
41 | #include <aia_capabilities_config.h>
42 | 
43 | #ifdef __cplusplus
44 | }
45 | #endif
46 | #endif /* ifndef AIA_CONFIG_H_ */
47 | 


--------------------------------------------------------------------------------
/ports/Microphone/include/microphone/aia_microphone_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_MICROPHONE_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_MICROPHONE_CONFIG_H_
22 | 
23 | #include <stdlib.h>
24 | 
25 | /** How often data will be published on the /microphone topic. */
26 | #define MICROPHONE_PUBLISH_RATE ( (AiaDurationMs_t)50 )
27 | 
28 | /**
29 |  * The amount of microphone samples that will be published when the microphone
30 |  * is open per @c MICROPHONE_PUBLISH_RATE iteration.
31 |  *
32 |  * @note 800 samples represents the real time rate for 50 ms. However, in
33 |  * situations involving preroll (wakeword), UPL will benefit from reading faster
34 |  * than the real-time rate. Ideally, this should be set to the largest value
35 |  * possible not exceeded the device's maximum MQTT message size that the device
36 |  * is capable of publishing.
37 |  */
38 | static const size_t AIA_MICROPHONE_CHUNK_SIZE_SAMPLES = 1600;
39 | 
40 | #ifdef __cplusplus
41 | }
42 | #endif
43 | #endif /* ifndef AIA_MICROPHONE_CONFIG_H_ */
44 | 


--------------------------------------------------------------------------------
/ports/Memory/include/memory/aia_memory_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_MEMORY_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_MEMORY_CONFIG_H_
22 | 
23 | #include <stdlib.h>
24 | 
25 | /**
26 |  * Allocates zero'd memory.  Memory allocated using this function should be
27 |  * released using a call to @c AiaFree().
28 |  *
29 |  * @param count The number of elements to allocate.
30 |  * @param size The size (in bytes) of each element.
31 |  * @return A @c void pointer to the allocated memory, or @c NULL if the memory
32 |  * cannot be allocated.
33 |  */
34 | static inline void* AiaCalloc( size_t count, size_t size )
35 | {
36 |     void* ptr = pvPortMalloc( count * size );
37 | 
38 |     if (ptr)
39 |     {
40 |         memset(ptr, 0, count * size);
41 |     }
42 |     return ptr;
43 | }
44 | 
45 | /** Releases memory allocated by a call to @c AiaCalloc(). */
46 | static inline void AiaFree( void* ptr )
47 | {
48 |     vPortFree( ptr );
49 | }
50 | 
51 | #ifdef __cplusplus
52 | }
53 | #endif
54 | #endif /* ifndef AIA_MEMORY_CONFIG_H_ */
55 | 


--------------------------------------------------------------------------------
/ports/Clock/include/clock/aia_clock_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_CLOCK_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_CLOCK_CONFIG_H_
22 | 
23 | #include <stddef.h>
24 | #include <stdint.h>
25 | 
26 | /** Macros and typedefs for clock functions. We require the typedefs to be
27 |  * fixed-size POD types. */
28 | /** @{ */
29 | 
30 | typedef uint64_t AiaTimepointMs_t;
31 | typedef uint32_t AiaDurationMs_t;
32 | typedef uint64_t AiaTimepointSeconds_t;
33 | typedef uint32_t AiaDurationSeconds_t;
34 | 
35 | /**
36 |  * @name AIA clock-capability related functionality. Implementations are
37 |  * expected to be thread-safe.
38 |  */
39 | /** @{ */
40 | 
41 | /**
42 |  * Retrieves the time since the NTP epoch (Jan 1, 1900) expressed in seconds.
43 |  *
44 |  * @return seconds since the NTP epoch.
45 |  */
46 | AiaTimepointSeconds_t AiaClock_GetTimeSinceNTPEpoch();
47 | 
48 | /**
49 |  * Synchronizes the device clock with a server provided time. This function will
50 |  * only be called if the application attempts to synchronize its clock with the
51 |  * service.
52 |  *
53 |  * @param secondsSinceNTPEpoch seconds since the NTP epoch. Note that this value
54 |  * is received from a remote service and a networking hops are not accounted
55 |  * for.
56 |  */
57 | void AiaClock_SetTimeSinceNTPEpoch(
58 |     AiaTimepointSeconds_t secondsSinceNTPEpoch );
59 | 
60 | /** @} */
61 | /** @} */
62 | 
63 | #ifdef __cplusplus
64 | }
65 | #endif
66 | #endif /* ifndef AIA_CLOCK_CONFIG_H_ */
67 | 


--------------------------------------------------------------------------------
/ports/Common/include/common/aia_common_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_COMMON_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_COMMON_CONFIG_H_
22 | 
23 | #include <microphone/aia_microphone_config.h>
24 | 
25 | #include <assert.h>
26 | #include <stddef.h>
27 | 
28 | /**
29 |  * Tests whether @c EXPRESSION is true, and terminates the application if it is
30 |  * not.
31 |  * @warning Applications may stub this out such that EXPRESSION is never
32 |  * evaluated, so application code should not depend on it.  For example, if @c
33 |  * AiaAssert() is implemented using @c assert(), the asserts will all be
34 |  * disabled uf @c NDEBUG is defined.
35 |  *
36 |  * @param EXPRESSION A boolean expression to evaluate and assert is true.
37 |  */
38 | #define AiaAssert( EXPRESSION ) assert( ( EXPRESSION ) )
39 | 
40 | /**
41 |  * For those platform do not define ssize_t type
42 |  */
43 | typedef long ssize_t;
44 | 
45 | /**
46 |  * This function will be called by the SDK when critical un-recoverable failures
47 |  * occur. Examples include memory allocation failures.
48 |  */
49 | static inline void AiaCriticalFailure()
50 | {
51 |     AiaLogError( "AiaCriticalFailure" );
52 |     AiaAssert(0);   // or use iot_reset_reboot(True) by vendors' implementation
53 | }
54 | 
55 | /** How often data will be published on the /event topic. */
56 | static const AiaDurationMs_t EVENT_PUBLISH_RATE = MICROPHONE_PUBLISH_RATE;
57 | 
58 | /** How many slots to be used in a sequencing buffer. */
59 | static const size_t AIA_SEQUENCER_SLOTS = 4;
60 | 
61 | #ifdef __cplusplus
62 | }
63 | #endif
64 | #endif /* ifndef AIA_COMMON_CONFIG_H_ */
65 | 


--------------------------------------------------------------------------------
/ports/IoT/src/aia_iot_config.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_iot_config.c
19 |  */
20 | 
21 | #include <iot/aia_iot_config.h>
22 | 
23 | bool AiaMqttPublish( AiaMqttConnectionPointer_t connection, AiaMqttQos_t qos,
24 |                      const char* topic, size_t topicLength, const void* message,
25 |                      size_t messageLength )
26 | {
27 |     if( !connection )
28 |     {
29 |         AiaLogError( "Null connection." );
30 |         return false;
31 |     }
32 |     if( !topic )
33 |     {
34 |         AiaLogError( "Null topic." );
35 |         return false;
36 |     }
37 |     if( !topicLength )
38 |     {
39 |         topicLength = strlen( topic );
40 |     }
41 |     if( !message )
42 |     {
43 |         AiaLogError( "Null message." );
44 |         return false;
45 |     }
46 |     if( !messageLength )
47 |     {
48 |         messageLength = strlen( message );
49 |     }
50 |     IotMqttPublishInfo_t topicPublish = { .qos = qos,
51 |                                           .pTopicName = topic,
52 |                                           .topicNameLength = topicLength,
53 |                                           .pPayload = message,
54 |                                           .payloadLength = messageLength,
55 |                                           .retryMs = MQTT_RETRY_TIMEOUT_MS,
56 |                                           .retryLimit = MQTT_RETRY_LIMIT };
57 | 
58 |     AiaLogDebug( "[AiaMqttPublish] %.*s", topicLength, topic );
59 | 
60 |     /** TODO: ADSER-1400 Use non-blocking MQTT publish. */
61 |     return IOT_MQTT_SUCCESS == IotMqtt_TimedPublish( connection, &topicPublish,
62 |                                                      0, MQTT_TIMEOUT_MS );
63 | }
64 | 


--------------------------------------------------------------------------------
/demos/aia/aia_sample_app.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_sample_app.h
19 |  * @brief User-facing functions of the @c AiaSampleApp_t type.
20 |  */
21 | 
22 | #ifndef AIA_SAMPLE_APP_H_
23 | #define AIA_SAMPLE_APP_H_
24 | 
25 | /* The config header is always included first. */
26 | #include <aia_config.h>
27 | 
28 | /**
29 |  * A sample application type that creates and runs the application via keyboard
30 |  * inputs. The returned pointer should be destroyed using @c
31 |  * AiaSampleApp_Destroy().
32 |  */
33 | typedef struct AiaSampleApp AiaSampleApp_t;
34 | 
35 | /**
36 |  * Creates all underlying Aia components.
37 |  *
38 |  * @param mqttConnection Handle to a connected MQTT connection.
39 |  * @param iotClientId Null-terminated IoT Client Id string for the device.
40 |  * @return A newly created @c AiaSampleApp_t if successful or @c NULL otherwise.
41 |  */
42 | AiaSampleApp_t* AiaSampleApp_Create( AiaMqttConnectionPointer_t mqttConnection,
43 |                                      const char* iotClientId );
44 | 
45 | /**
46 |  * Uninitializes and deallocates an @c AiaSampleApp_t previously created
47 |  * by a call to @c AiaSampleApp_Create().
48 |  *
49 |  * @param sampleApp The @c AiaSampleApp_t to destroy.
50 |  */
51 | void AiaSampleApp_Destroy( AiaSampleApp_t* sampleApp );
52 | 
53 | /* TODO: ADSER-1689 Allow for running on single-threaded machines. Make
54 |  * non-blocking. */
55 | /**
56 |  * This is a blocking function that processes user inputs via @c stdin. This
57 |  * function will return when a user inputs a command to quit.
58 |  *
59 |  * @param sampleApp The @c AiaSampleApp_t to act on.
60 |  */
61 | void AiaSampleApp_Run( AiaSampleApp_t* sampleApp );
62 | 
63 | #endif /* ifndef AIA_SAMPLE_APP_H_ */
64 | 


--------------------------------------------------------------------------------
/ports/LWA/src/aia_lwa_config.c:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_lwa_config.c
19 |  * @brief Implements platform-specific LWA functions which are not inlined
20 |  * in
21 |  * @c aia_lwa_config.h.
22 |  */
23 | 
24 | #include <iot/aia_iot_config.h>
25 | #include <lwa/aia_lwa_config.h>
26 | 
27 | char* g_aiaLwaRefreshToken;
28 | char* g_aiaLwaClientId;
29 | 
30 | bool AiaGetRefreshToken( char* refreshToken, size_t* len )
31 | {
32 |     if( !len )
33 |     {
34 |         AiaLogError( "Null len." );
35 |         return false;
36 |     }
37 |     size_t refreshTokenLen = strlen( g_aiaLwaRefreshToken ) + 1;
38 |     if( refreshToken )
39 |     {
40 |         /* TODO: ADSER-1938 Implement LWA calls. */
41 |         if( *len < refreshTokenLen )
42 |         {
43 |             AiaLogError(
44 |                 "refreshToken buffer too small to hold refresh token." );
45 |             return false;
46 |         }
47 |         strncpy( refreshToken, g_aiaLwaRefreshToken, refreshTokenLen );
48 |     }
49 |     *len = refreshTokenLen;
50 |     return true;
51 | }
52 | 
53 | bool AiaGetLwaClientId( char* lwaClientId, size_t* len )
54 | {
55 |     if( !len )
56 |     {
57 |         AiaLogError( "Null len." );
58 |         return false;
59 |     }
60 |     size_t lwaClientIdLen = strlen( g_aiaLwaClientId ) + 1;
61 |     if( lwaClientId )
62 |     {
63 |         /* TODO: ADSER-1938 Implement LWA calls. */
64 |         if( *len < lwaClientIdLen )
65 |         {
66 |             AiaLogError(
67 |                 "lwaClientId buffer too small to hold LWA Client Id." );
68 |             return false;
69 |         }
70 |         strncpy( lwaClientId, g_aiaLwaClientId, lwaClientIdLen );
71 |     }
72 |     *len = lwaClientIdLen;
73 |     return true;
74 | }
75 | 


--------------------------------------------------------------------------------
/ports/LWA/include/lwa/aia_lwa_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_LWA_CONFIG_H_
18 | #ifdef __cplusplus
19 | extern "C" {
20 | #endif
21 | #define AIA_LWA_CONFIG_H_
22 | 
23 | #include <stdbool.h>
24 | #include <stddef.h>
25 | 
26 | /**
27 |  * Retrieves the LWA refresh token. The LWA refresh token returned is
28 |  * null-terminated. If @c NULL is passed for @c refreshToken, this function will
29 |  * store the buffer length needed to store the LWA refresh token into @c len and
30 |  * return true if successful.
31 |  *
32 |  * @param[out] refreshToken A user provided buffer.
33 |  * @param[in, out] len Pointer to the length of @c refreshToken. If LWA refresh
34 |  * token is successfully retrieved this will be set to the length of the token
35 |  * that will be copied into @c buffer. This includes space for a
36 |  * trailing @c '\0'.
37 |  * @return @c true if successful or @c false otherwise.
38 |  */
39 | bool AiaGetRefreshToken( char* refreshToken, size_t* len );
40 | 
41 | /**
42 |  * Retrieves the LWA Client Id. The LWA Client Id returned is
43 |  * null-terminated. If @c NULL is passed for @c lwaClientId, this function
44 |  * will store the buffer length needed to store the LWA Client Id into @c
45 |  * len and return true if successful.
46 |  *
47 |  * @param[out] lwaClientId A user provided buffer.
48 |  * @param[in, out] len Pointer to the length of @c lwaClientId. If LWA
49 |  * Client Id is successfully retrieved this will be set to the length of the
50 |  * token that will be copied into @c buffer. This includes space for
51 |  * a trailing @c '\0'.
52 |  * @return @c true if entire LWA Client Id is copied to the @c lwaClientId,
53 |  * else @c false.
54 |  */
55 | bool AiaGetLwaClientId( char* lwaClientId, size_t* len );
56 | 
57 | #ifdef __cplusplus
58 | }
59 | #endif
60 | #endif /* ifndef AIA_LWA_CONFIG_H_ */
61 | 


--------------------------------------------------------------------------------
/demos/aia/utils/aiaportaudiomicrophone/include/aiaportaudiomicrophone/aia_portaudio_microphone.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_portaudio_microphone.c
19 |  * @brief Reference implementation of a microphone recorder using PortAudio
20 |  */
21 | 
22 | #ifndef AIA_PORTAUDIO_MICROPHONE_H_
23 | #ifdef __cplusplus
24 | extern "C" {
25 | #endif
26 | #define AIA_PORTAUDIO_MICROPHONE_H_
27 | 
28 | /* The config header is always included first. */
29 | #include <aia_config.h>
30 | 
31 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer_writer.h>
32 | 
33 | #include <portaudio.h>
34 | 
35 | /**
36 |  * A thin wrapper around PortAudio used for recording microphone data. Methods
37 |  * of this object are thread-safe.
38 |  */
39 | typedef struct AiaPortAudioMicrophoneRecorder AiaPortAudioMicrophoneRecorder_t;
40 | 
41 | /**
42 |  * Creates an @c AiaPortAudioMicrophoneRecorder_t. The returned pointer should
43 |  * be destroyed using @c AiaPortAudioMicrophoneRecorder_Destroy().
44 |  *
45 |  * @param bufferWriter The writer to use to write microphone data into an @c
46 |  * AiaDataStreamBuffer_t.
47 |  * @return A newly created @c AiaPortAudioMicrophoneRecorder_t if successful or
48 |  * @c NULL otherwise.
49 |  */
50 | AiaPortAudioMicrophoneRecorder_t* AiaPortAudioMicrophoneRecorder_Create(
51 |     AiaDataStreamWriter_t* bufferWriter );
52 | 
53 | /**
54 |  * Uninitializes and deallocates an @c AiaPortAudioMicrophoneRecorder_t
55 |  * previously created by a call to
56 |  * @c AiaPortAudioMicrophoneRecorder_Create().
57 |  *
58 |  * @param recorder The @c AiaPortAudioMicrophoneRecorder_t to destroy.
59 |  */
60 | void AiaPortAudioMicrophoneRecorder_Destroy(
61 |     AiaPortAudioMicrophoneRecorder_t* recorder );
62 | 
63 | /**
64 |  * Starts streaming from the microphone.
65 |  *
66 |  * @param recorder The @c AiaPortAudioMicrophoneRecorder_t to act on.
67 |  * @return Whether the start was successful.
68 |  */
69 | bool AiaPortAudioMicrophoneRecorder_StartStreamingMicrophoneData(
70 |     AiaPortAudioMicrophoneRecorder_t* recorder );
71 | 
72 | /**
73 |  * Stops streaming from the microphone.
74 |  *
75 |  * @param recorder The @c AiaPortAudioMicrophoneRecorder_t to act on.
76 |  * @return Whether the stop was successful.
77 |  */
78 | bool AiaPortAudioMicrophoneRecorder_StopStreamingMicrophoneData(
79 |     AiaPortAudioMicrophoneRecorder_t* recorder );
80 | 
81 | #ifdef __cplusplus
82 | }
83 | #endif
84 | #endif /* ifndef AIA_PORTAUDIO_MICROPHONE_H_ */
85 | 


--------------------------------------------------------------------------------
/ports/Registration/include/registration/aia_registration_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | #ifndef AIA_REGISTRATION_CONFIG_H_
18 | #define AIA_REGISTRATION_CONFIG_H_
19 | 
20 | #include <stdbool.h>
21 | #include <stddef.h>
22 | 
23 | #define AIA_REGISTRATION_ENDPOINT \
24 |     "https://api.amazonalexa.com/v1/ais/registration"
25 | 
26 | /**
27 |  * Retrieves the IoT Client Id. The IoT Client Id returned is
28 |  * null-terminated. If @c NULL is passed for @c iotClientId, this function
29 |  * will store the buffer length needed to store the IoT Client Id into @c
30 |  * len and return true if successful.
31 |  *
32 |  * @param[out] iotClientId A user provided buffer.
33 |  * @param[in, out] len Pointer to the length of @c iotClientId. If IoT
34 |  * Client Id is successfully retrieved this will be set to the length of the
35 |  * token that will be copied into @c buffer. This includes space for
36 |  * a trailing @c '\0'.
37 |  * @return @c true if entire Iot Client Id is copied to the @c iotClientId,
38 |  * else @c false.
39 |  */
40 | bool AiaGetIotClientId( char* iotClientId, size_t* len );
41 | 
42 | /**
43 |  * Retrieves the AWS Account Id. The AWS Account Id returned is
44 |  * null-terminated. If @c NULL is passed for @c awsAccountId, this function
45 |  * will store the buffer length needed to store the AWS Account Id into @c
46 |  * len and return true if successful.
47 |  *
48 |  * @param[out] awsAccountId A user provided buffer.
49 |  * @param[in, out] len Pointer to the length of @c awsAccountId. If AWS
50 |  * Account Id is successfully retrieved this will be set to the length of
51 |  * the token that will be copied into @c buffer. This includes space for a
52 |  * trailing @c '\0'.
53 |  * @return @c true if entire AWS Account Id is copied into @c awsAccountId,
54 |  * else @c false.
55 |  */
56 | bool AiaGetAwsAccountId( char* awsAccountId, size_t* len );
57 | 
58 | /**
59 |  * Retrieves the IoT endpoint. The IoT endpoint returned is
60 |  * null-terminated. If @c NULL is passed for @c iotEndpoint, this function
61 |  * will store the buffer length needed to store the IoT endpoint into @c
62 |  * len and return true if successful.
63 |  *
64 |  * @param[out] iotEndpoint A user provided buffer.
65 |  * @param[in, out] len Pointer to the length of @c iotEndpoint. If IoT
66 |  * endpoint is successfully retrieved this will be set to the length of
67 |  * the token that will be copied into @c buffer. This includes space for a
68 |  * trailing @c '\0'.
69 |  * @return @c true if entire IoT endpoint is copied into @c iotEndpoint,
70 |  * else @c false.
71 |  */
72 | bool AiaGetIotEndpoint( char* iotEndpoint, size_t* len );
73 | 
74 | #endif /* ifndef AIA_REGISTRATION_CONFIG_H_ */
75 | 


--------------------------------------------------------------------------------
/ports/include/aia_capabilities_config.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *     http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | /**
18 |  * @file aia_capabilities_config.h
19 |  * @brief Configurable client capabilities.
20 |  */
21 | 
22 | #ifndef AIA_CAPABILITIES_CONFIG_H_
23 | #define AIA_CAPABILITIES_CONFIG_H_
24 | 
25 | #include <aiacore/aia_json_constants.h>
26 | 
27 | #include <stdint.h>
28 | 
29 | /**
30 |  * @name "Speaker" interface capabilities.
31 |  *
32 |  * If this interface is supported on
33 |  * this device, all below configurations must defined. If this interface is not
34 |  * supported on this device, all below configurations must be deleted entirely.
35 |  */
36 | /** @{ */
37 | #define AIA_ENABLE_SPEAKER
38 | #define AIA_AUDIO_BUFFER_SIZE UINT64_C( 128000 )
39 | static const AiaJsonLongType AIA_AUDIO_BUFFER_OVERRUN_WARN_THRESHOLD =
40 |     8 * AIA_AUDIO_BUFFER_SIZE / 10;
41 | static const AiaJsonLongType AIA_AUDIO_BUFFER_UNDERRUN_WARN_THRESHOLD =
42 |     2 * AIA_AUDIO_BUFFER_SIZE / 10;
43 | #define AIA_SPEAKER_AUDIO_DECODER_FORMAT "OPUS"
44 | #define AIA_SPEAKER_AUDIO_DECODER_BITRATE_TYPE "CONSTANT"
45 | static const AiaJsonLongType AIA_SPEAKER_AUDIO_DECODER_BITS_PER_SECOND = 64000;
46 | #define AIA_SPEAKER_AUDIO_DECODER_NUM_CHANNELS UINT64_C( 1 )
47 | /** @} */
48 | 
49 | /**
50 |  * @name "Microphone" interface capabilities.
51 |  *
52 |  * If this interface is supported on
53 |  * this device, all below configurations must defined. If this interface is not
54 |  * supported on this device, all below configurations must be deleted entirely.
55 |  */
56 | /** @{ */
57 | #define AIA_ENABLE_MICROPHONE
58 | #define AIA_MICROPHONE_AUDIO_ENCODER_FORMAT "AUDIO_L16_RATE_16000_CHANNELS_1"
59 | /** @} */
60 | 
61 | /**
62 |  * @name "Alerts" interface capabilities.
63 |  *
64 |  * If this interface is supported on
65 |  * this device, all below configurations must defined. If this interface is not
66 |  * supported on this device, all below configurations must be deleted entirely.
67 |  */
68 | /** @{ */
69 | #define AIA_ENABLE_ALERTS
70 | static const AiaJsonLongType AIA_ALERTS_MAX_ALERT_COUNT = 20;
71 | /** @} */
72 | 
73 | /**
74 |  * @name "Alerts" interface capabilities.
75 |  *
76 |  * If this interface is supported on
77 |  * this device, all below configurations must defined. If this interface is not
78 |  * supported on this device, all below configurations must be deleted entirely.
79 |  */
80 | /** @{ */
81 | #define AIA_ENABLE_CLOCK
82 | /** @} */
83 | 
84 | /**
85 |  * @name "System" interface capabilities.
86 |  */
87 | /** @{ */
88 | #define AIA_ENABLE_SYSTEM
89 | static const AiaJsonLongType AIA_SYSTEM_MQTT_MESSAGE_MAX_SIZE = 8000;
90 | #define AIA_SYSTEM_FIRMWARE_VERSION "42"
91 | #define AIA_SYSTEM_LOCALE "en-US"
92 | /** @} */
93 | 
94 | #endif /* ifndef AIA_CAPABILITIES_CONFIG_H_ */
95 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing Guidelines
 2 | 
 3 | Thank you for your interest in contributing to our project. Whether it's a bug report, new feature, correction, or additional
 4 | documentation, we greatly value feedback and contributions from our community.
 5 | 
 6 | Please read through this document before submitting any issues or pull requests to ensure we have all the necessary
 7 | information to effectively respond to your bug report or contribution.
 8 | 
 9 | 
10 | ## Reporting Bugs/Feature Requests
11 | 
12 | We welcome you to use the GitHub issue tracker to report bugs or suggest features.
13 | 
14 | When filing an issue, please check existing open, or recently closed, issues to make sure somebody else hasn't already
15 | reported the issue. Please try to include as much information as you can. Details like these are incredibly useful:
16 | 
17 | * A reproducible test case or series of steps
18 | * The version of our code being used
19 | * Any modifications you've made relevant to the bug
20 | * Anything unusual about your environment or deployment
21 | 
22 | 
23 | ## Contributing via Pull Requests
24 | Contributions via pull requests are much appreciated. Before sending us a pull request, please ensure that:
25 | 
26 | 1. You are working against the latest source on the *master* branch.
27 | 2. You check existing open, and recently merged, pull requests to make sure someone else hasn't addressed the problem already.
28 | 3. You open an issue to discuss any significant work - we would hate for your time to be wasted.
29 | 
30 | To send us a pull request, please:
31 | 
32 | 1. Fork the repository.
33 | 2. Modify the source; please focus on the specific change you are contributing. If you also reformat all the code, it will be hard for us to focus on your change.
34 | 3. Ensure local tests pass.
35 | 4. Commit to your fork using clear commit messages.
36 | 5. Send us a pull request, answering any default questions in the pull request interface.
37 | 6. Pay attention to any automated CI failures reported in the pull request, and stay involved in the conversation.
38 | 
39 | GitHub provides additional document on [forking a repository](https://help.github.com/articles/fork-a-repo/) and
40 | [creating a pull request](https://help.github.com/articles/creating-a-pull-request/).
41 | 
42 | 
43 | ## Finding contributions to work on
44 | Looking at the existing issues is a great way to find something to contribute on. As our projects, by default, use the default GitHub issue labels (enhancement/bug/duplicate/help wanted/invalid/question/wontfix), looking at any 'help wanted' issues is a great place to start.
45 | 
46 | 
47 | ## Code of Conduct
48 | This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
49 | For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
50 | opensource-codeofconduct@amazon.com with any additional questions or comments.
51 | 
52 | 
53 | ## Security issue notifications
54 | If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/). Please do **not** create a public github issue.
55 | 
56 | 
57 | ## Licensing
58 | 
59 | See the [LICENSE](LICENSE) file for our project's licensing. We will ask you to confirm the licensing of your contribution.
60 | 
61 | We may ask you to sign a [Contributor License Agreement (CLA)](http://en.wikipedia.org/wiki/Contributor_License_Agreement) for larger changes.
62 | 


--------------------------------------------------------------------------------
/ports/Registration/src/aia_registration_config.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_registration_config.c
 19 |  * @brief Implements platform-specific Registration functions which are not
 20 |  * inlined in
 21 |  * @c aia_registration_config.h.
 22 |  */
 23 | 
 24 | #include <registration/aia_registration_config.h>
 25 | 
 26 | #include <aia_config.h>
 27 | 
 28 | const char* g_aiaIotEndpoint;
 29 | const char* g_aiaClientId;
 30 | const char* g_aiaAwsAccountId;
 31 | 
 32 | bool AiaGetIotClientId( char* iotClientId, size_t* len )
 33 | {
 34 |     if( !len )
 35 |     {
 36 |         AiaLogError( "Null len." );
 37 |         return false;
 38 |     }
 39 | 
 40 |     size_t iotClientIdLen = strlen( g_aiaClientId ) + 1;
 41 |     if( !iotClientIdLen )
 42 |     {
 43 |         AiaLogError( "Failed to retrieve IoT Client Id length" );
 44 |         return false;
 45 |     }
 46 |     if( iotClientId )
 47 |     {
 48 |         if( *len < iotClientIdLen )
 49 |         {
 50 |             AiaLogError(
 51 |                 "iotClientId buffer too small to hold IoT Client Id." );
 52 |             return false;
 53 |         }
 54 |         strncpy( iotClientId, g_aiaClientId, iotClientIdLen );
 55 |     }
 56 |     *len = iotClientIdLen;
 57 |     return true;
 58 | }
 59 | 
 60 | bool AiaGetAwsAccountId( char* awsAccountId, size_t* len )
 61 | {
 62 |     if( !len )
 63 |     {
 64 |         AiaLogError( "Null len." );
 65 |         return false;
 66 |     }
 67 | 
 68 |     size_t awsAccountIdLen = strlen( g_aiaAwsAccountId ) + 1;
 69 |     if( !awsAccountIdLen )
 70 |     {
 71 |         AiaLogError( "Failed to retrieve AWS Account Id length" );
 72 |         return false;
 73 |     }
 74 |     if( awsAccountId )
 75 |     {
 76 |         if( *len < awsAccountIdLen )
 77 |         {
 78 |             AiaLogError(
 79 |                 "awsAccountId buffer too small to hold AWS Account Id." );
 80 |             return false;
 81 |         }
 82 |         strncpy( awsAccountId, g_aiaAwsAccountId, awsAccountIdLen );
 83 |     }
 84 |     *len = awsAccountIdLen;
 85 |     return true;
 86 | }
 87 | 
 88 | bool AiaGetIotEndpoint( char* iotEndpoint, size_t* len )
 89 | {
 90 |     if( !len )
 91 |     {
 92 |         AiaLogError( "Null len." );
 93 |         return false;
 94 |     }
 95 | 
 96 |     size_t iotEndpointLen = strlen( g_aiaIotEndpoint ) + 1;
 97 |     if( !iotEndpointLen )
 98 |     {
 99 |         AiaLogError( "Failed to retrieve IoT endpoint length" );
100 |         return false;
101 |     }
102 |     if( iotEndpoint )
103 |     {
104 |         if( *len < iotEndpointLen )
105 |         {
106 |             AiaLogError( "iotEndpoint buffer too small to hold IoT endpoint." );
107 |             return false;
108 |         }
109 |         strncpy( iotEndpoint, g_aiaIotEndpoint, iotEndpointLen );
110 |     }
111 |     *len = iotEndpointLen;
112 |     return true;
113 | }
114 | 


--------------------------------------------------------------------------------
/ports/Clock/src/aia_clock_config.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_clock_config.c
 19 |  * @brief Implements platform-specific clock functions which are not inlined
 20 |  * in
 21 |  * @c aia_clock_config.h.
 22 |  */
 23 | 
 24 | #include <clock/aia_clock_config.h>
 25 | #include <iot/aia_iot_config.h>
 26 | 
 27 | #include <aiacore/aia_utils.h>
 28 | 
 29 | #include AiaClock( HEADER )
 30 | 
 31 | #include <time.h>
 32 | 
 33 | #define AIA_CLOCK_YEARS_BEWEEN_NTC_AND_UTC_EPOCH 70
 34 | #define AIA_CLOCK_DAYS_PER_YEAR 365
 35 | #define AIA_CLOCK_NUM_EXTRA_DAYS_BETWEEN_NTC_AND_UTC_EPOCH 17
 36 | #define AIA_CLOCK_SECONDS_PER_DAY 86400UL
 37 | 
 38 | /** @name Variables synchronized by g_spinLock. */
 39 | /** @{ */
 40 | 
 41 | /* Holds last synchronized, or initial time if synchronization has not occurred
 42 |  * yet. */
 43 | static AiaTimepointSeconds_t g_lastRetrievedTimeSinceNTPEpoch;
 44 | 
 45 | /* Default last synchronization time to initialization time, expressed in terms
 46 |  * of a monotonically increasing clock. */
 47 | static AiaTimepointSeconds_t g_lastSynchronization;
 48 | 
 49 | /* State that tracks whether the system clock is synchronized with the AIA
 50 |  * server or not. */
 51 | static bool g_serverSynchronized = false;
 52 | 
 53 | /** @} */
 54 | 
 55 | /** Simple spin lock boolean flag to guard against asynchronous reads/writes to
 56 |  * the below clock functions. */
 57 | static AiaAtomicBool_t g_spinLock = false;
 58 | 
 59 | AiaTimepointSeconds_t AiaClock_GetTimeSinceNTPEpoch()
 60 | {
 61 |     while( !Atomic_CompareAndSwap_u32( &g_spinLock, 1, 0 ) )
 62 |     {
 63 |         /* spin lock, inefficient */
 64 |     }
 65 |     if( !g_serverSynchronized )
 66 |     {
 67 |         /* RFC 868 */
 68 |         static const AiaTimepointSeconds_t UNIX_NTP_EPOCH_DELTA_SECONDS =
 69 |             2208988800;
 70 |         /* Initial retrieval of time from system. */
 71 |         /* Although not defined by the C standard, this is almost always an
 72 |          * integral value holding the number of seconds (not counting leap
 73 |          * seconds) since 00:00, Jan 1 1970 UTC, corresponding to POSIX time. */
 74 |         g_lastRetrievedTimeSinceNTPEpoch =
 75 |             time( NULL ) + UNIX_NTP_EPOCH_DELTA_SECONDS;
 76 |         g_lastSynchronization = AiaClock( GetTimeMs )() / AIA_MS_PER_SECOND;
 77 |     }
 78 |     AiaTimepointSeconds_t ret =
 79 |         g_lastRetrievedTimeSinceNTPEpoch +
 80 |         ( ( AiaClock( GetTimeMs )() / AIA_MS_PER_SECOND ) -
 81 |           g_lastSynchronization );
 82 |     AiaAtomicBool_Clear( &g_spinLock );
 83 |     return ret;
 84 | }
 85 | 
 86 | void AiaClock_SetTimeSinceNTPEpoch( AiaTimepointSeconds_t secondsSinceNTPEpoch )
 87 | {
 88 |     time_t secondsSinceUtcEpoch =
 89 |         secondsSinceNTPEpoch -
 90 |         ( AIA_CLOCK_YEARS_BEWEEN_NTC_AND_UTC_EPOCH * AIA_CLOCK_DAYS_PER_YEAR +
 91 |           AIA_CLOCK_NUM_EXTRA_DAYS_BETWEEN_NTC_AND_UTC_EPOCH ) *
 92 |             AIA_CLOCK_SECONDS_PER_DAY;
 93 |     AiaLogInfo( "UTC time = %s", asctime( gmtime( &secondsSinceUtcEpoch ) ) );
 94 | 
 95 |     while( !Atomic_CompareAndSwap_u32( &g_spinLock, 1, 0 ) )
 96 |     {
 97 |         /* spin lock, inefficient */
 98 |     }
 99 |     g_serverSynchronized = true;
100 |     g_lastSynchronization = AiaClock( GetTimeMs )() / AIA_MS_PER_SECOND;
101 |     g_lastRetrievedTimeSinceNTPEpoch = secondsSinceNTPEpoch;
102 |     AiaAtomicBool_Clear( &g_spinLock );
103 | }
104 | 


--------------------------------------------------------------------------------
/patch/AiaClientSDK_0deab3e0.patch:
--------------------------------------------------------------------------------
  1 | diff --git a/AiaCore/include/aiaspeakermanager/aia_speaker_manager.h b/AiaCore/include/aiaspeakermanager/aia_speaker_manager.h
  2 | index bfdc13c..d5ffd7a 100644
  3 | --- a/AiaCore/include/aiaspeakermanager/aia_speaker_manager.h
  4 | +++ b/AiaCore/include/aiaspeakermanager/aia_speaker_manager.h
  5 | @@ -25,7 +25,7 @@
  6 |  
  7 |  /* TODO: ADSER-1867 Calculate this internally at runtime based on Opus frame
  8 |   * size and configured capabilities. */
  9 | -#define AIA_SPEAKER_FRAME_PUSH_CADENCE_MS 20
 10 | +#define AIA_SPEAKER_FRAME_PUSH_CADENCE_MS AIA_CLOCK_ARM_MS_MIN
 11 |  
 12 |  /**
 13 |   * This type is used to manage the speaker data flowing through the system. It
 14 | diff --git a/AiaCore/source/aiacore/aia_mbedtls_threading.c b/AiaCore/source/aiacore/aia_mbedtls_threading.c
 15 | index c1d2b96..2678824 100644
 16 | --- a/AiaCore/source/aiacore/aia_mbedtls_threading.c
 17 | +++ b/AiaCore/source/aiacore/aia_mbedtls_threading.c
 18 | @@ -28,20 +28,24 @@
 19 |  /**
 20 |   * Initializes a new mutex. Used by mbed TLS to provide thread-safety.
 21 |   *
 22 | - * Sets the valid member of `mbedtls_threading_mutex_t`.
 23 | + * Sets the is_valid member of `mbedtls_threading_mutex_t`.
 24 |   *
 25 |   * @param[in] mbedtlsMutex The mutex to initialize.
 26 |   */
 27 |  static void _AiaMbedtlsThreading_MutexInit(
 28 |      mbedtls_threading_mutex_t* mbedtlsMutex )
 29 |  {
 30 | -    mbedtlsMutex->mutex = AiaCalloc( sizeof( AiaMutex_t ), 1 );
 31 | -    if( !mbedtlsMutex->mutex )
 32 | +    mbedtlsMutex->mutex = xSemaphoreCreateMutex();
 33 | +
 34 | +    if( mbedtlsMutex->mutex != NULL )
 35 |      {
 36 | -        AiaLogError( "Failed to allocate %zu bytes.", sizeof( AiaMutex_t ) );
 37 | -        mbedtlsMutex->valid = false;
 38 | +        mbedtlsMutex->is_valid = 1;
 39 | +    }
 40 | +    else
 41 | +    {
 42 | +        mbedtlsMutex->is_valid = 0;
 43 | +        AiaLogError( "Failed to initialize mbedTLS mutex." );
 44 |      }
 45 | -    mbedtlsMutex->valid = AiaMutex( Create )( mbedtlsMutex->mutex, false );
 46 |  }
 47 |  
 48 |  /**
 49 | @@ -52,11 +56,10 @@ static void _AiaMbedtlsThreading_MutexInit(
 50 |  static void _AiaMbedtlsThreading_MutexFree(
 51 |      mbedtls_threading_mutex_t* mbedtlsMutex )
 52 |  {
 53 | -    if( mbedtlsMutex->valid == true )
 54 | +    if( mbedtlsMutex->is_valid == 1 )
 55 |      {
 56 | -        AiaMutex( Destroy )( mbedtlsMutex->mutex );
 57 | -        AiaFree( mbedtlsMutex->mutex );
 58 | -        mbedtlsMutex->valid = false;
 59 | +        vSemaphoreDelete( mbedtlsMutex->mutex );
 60 | +        mbedtlsMutex->is_valid = 0;
 61 |      }
 62 |  }
 63 |  
 64 | @@ -71,18 +74,22 @@ static void _AiaMbedtlsThreading_MutexFree(
 65 |  static int _AiaMbedtlsThreading_MutexLock(
 66 |      mbedtls_threading_mutex_t* mbedtlsMutex )
 67 |  {
 68 | -    int status = 0;
 69 | +    int ret = MBEDTLS_ERR_THREADING_BAD_INPUT_DATA;
 70 |  
 71 | -    if( mbedtlsMutex->valid == false )
 72 | -    {
 73 | -        status = MBEDTLS_ERR_THREADING_BAD_INPUT_DATA;
 74 | -    }
 75 | -    else
 76 | +    if( mbedtlsMutex->is_valid == 1 )
 77 |      {
 78 | -        AiaMutex( Lock )( mbedtlsMutex->mutex );
 79 | +        if( xSemaphoreTake( mbedtlsMutex->mutex, portMAX_DELAY ) )
 80 | +        {
 81 | +            ret = 0;
 82 | +        }
 83 | +        else
 84 | +        {
 85 | +            ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
 86 | +            AiaLogError( "Failed to obtain mbedTLS mutex." );
 87 | +        }
 88 |      }
 89 |  
 90 | -    return status;
 91 | +    return ret;
 92 |  }
 93 |  
 94 |  /**
 95 | @@ -96,18 +103,22 @@ static int _AiaMbedtlsThreading_MutexLock(
 96 |  static int _AiaMbedtlsThreading_MutexUnlock(
 97 |      mbedtls_threading_mutex_t* mbedtlsMutex )
 98 |  {
 99 | -    int status = 0;
100 | +    int ret = MBEDTLS_ERR_THREADING_BAD_INPUT_DATA;
101 |  
102 | -    if( mbedtlsMutex->valid == false )
103 | -    {
104 | -        status = MBEDTLS_ERR_THREADING_BAD_INPUT_DATA;
105 | -    }
106 | -    else
107 | +    if( mbedtlsMutex->is_valid == 1 )
108 |      {
109 | -        AiaMutex( Unlock )( mbedtlsMutex->mutex );
110 | +        if( xSemaphoreGive( mbedtlsMutex->mutex ) )
111 | +        {
112 | +            ret = 0;
113 | +        }
114 | +        else
115 | +        {
116 | +            ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
117 | +            AiaLogError( "Failed to unlock mbedTLS mutex." );
118 | +        }
119 |      }
120 |  
121 | -    return status;
122 | +    return ret;
123 |  }
124 |  
125 |  void AiaMbedtlsThreading_Init()
126 | 


--------------------------------------------------------------------------------
/ports/HTTP/include/http/aia_http_config.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #ifndef AIA_HTTP_CONFIG_H_
 18 | #ifdef __cplusplus
 19 | extern "C" {
 20 | #endif
 21 | #define AIA_HTTP_CONFIG_H_
 22 | 
 23 | #include <stdbool.h>
 24 | #include <stddef.h>
 25 | #include "iot_config.h"
 26 | #include "platform/iot_network.h"
 27 | 
 28 | /**
 29 |  * @name Sending HTTPS requests to a URL using HTTP/1.1. AIA only requires
 30 |  * sending POST HTTPS messages for registration with support for redirects. */
 31 | /** @{ */
 32 | 
 33 | /**
 34 |  * HTTP methods from RFC2616. AIA only requires sending POST HTTPS messages for
 35 |  * registration.
 36 |  */
 37 | typedef enum AiaHttpsMethod
 38 | {
 39 |     AIA_HTTPS_METHOD_POST
 40 | } AiaHttpsMethod_t;
 41 | 
 42 | /* Contain information needed to make a HTTPS request. */
 43 | typedef struct AiaHttpsRequest
 44 | {
 45 |     /** The HTTP method to use in the request. */
 46 |     AiaHttpsMethod_t method;
 47 | 
 48 |     /** Array of C-strings to be sent as headers in the request. */
 49 |     const char** headers;
 50 | 
 51 |     /** Size of @c headers. */
 52 |     size_t headersLen;
 53 | 
 54 |     /** The URL to use in the request, as a C-string.*/
 55 |     const char* url;
 56 | 
 57 |     /** Data to send as the body of the request to the server, as a C-string. */
 58 |     const char* body;
 59 | } AiaHttpsRequest_t;
 60 | 
 61 | /* Contains HTTPS response information */
 62 | typedef struct AiaHttpsResponse
 63 | {
 64 |     /** The response code received. */
 65 |     size_t status;
 66 | 
 67 |     /** The body of the response. */
 68 |     char* body;
 69 | 
 70 |     /** Length of @c body. */
 71 |     size_t bodyLen;
 72 | } AiaHttpsResponse_t;
 73 | 
 74 | /**
 75 |  * This callback function is used when a failure is encountered in making the
 76 |  * request.
 77 |  * @note Implementations are not required to be thread-safe.
 78 |  *
 79 |  * @param userData Optional user data pointer which was provided alongside the
 80 |  * callback.
 81 |  */
 82 | typedef void ( *AiaHttpsConnectionFailureCallback_t )( void* userData );
 83 | 
 84 | /**
 85 |  * This callback function is used after a response is received from the server
 86 |  * following a request.
 87 |  * @note Implementations are not required to be thread-safe.
 88 |  *
 89 |  * @param httpsResponse The HTTPS response received from the server.
 90 |  * @param userData Optional user data pointer which was provided alongside the
 91 |  * callback.
 92 |  */
 93 | typedef void ( *AiaHttpsConnectionResponseCallback_t )(
 94 |     AiaHttpsResponse_t* httpsResponse, void* userData );
 95 | 
 96 | /**
 97 |  * Store AFR network information for later use.
 98 |  *
 99 |  * @param pNetworkInterface AFR demo network interfaces.
100 |  * @param pNetworkCredentialInfo AFR demo network Credential
101 |  * @return @c true if the request was able to be performed successfully or @c
102 |  * false otherwise.
103 |  */
104 | bool AiaHttpStoreNetworkInfo(const IotNetworkInterface_t* pNetworkInterface,
105 |                              const void* pNetworkCredentialInfo );
106 | 
107 | /**
108 |  * Sends a HTTPS request. Implementation must be using HTTP/1.1 and follow
109 |  * redirects.
110 |  * @note A callback to @c responseCallback or @c failureCallback will only be
111 |  * made if @c true is returned.
112 |  * @note Implementations are not required to be thread-safe.
113 |  *
114 |  * @param httpsRequest Information used for sending the HTTPS request.
115 |  * @param responseCallback A callback for when a response is received from the
116 |  * server.
117 |  * @param responseCallbackUserData User data to pass to @c responseCallback.
118 |  * @param failureCallback A callback for when a failure in encountered making
119 |  * the request.
120 |  * @param failureCallbackUserData User data to pass to @c failureCallback.
121 |  * @return @c true if the request was able to be performed successfully or @c
122 |  * false otherwise.
123 |  */
124 | bool AiaSendHttpsRequest( AiaHttpsRequest_t* httpsRequest,
125 |                           AiaHttpsConnectionResponseCallback_t responseCallback,
126 |                           void* responseCallbackUserData,
127 |                           AiaHttpsConnectionFailureCallback_t failureCallback,
128 |                           void* failureCallbackUserData );
129 | /** @} */
130 | 
131 | #ifdef __cplusplus
132 | }
133 | #endif
134 | #endif /* ifndef AIA_HTTP_CONFIG_H_ */
135 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 3.11 FATAL_ERROR)
  2 | if(${CMAKE_VERSION} VERSION_LESS 3.18)
  3 |     cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
  4 | else()
  5 |     cmake_policy(VERSION 3.18)
  6 | endif()
  7 | 
  8 | # Set project information
  9 | project(AiaClientSDK VERSION 0.0.0 LANGUAGES C)
 10 | set(PROJECT_BRIEF "A cross-platform SDK for interacting with the AVS for AWS IoT Core")
 11 | 
 12 | # Enable more verbose 'check' target
 13 | add_custom_target( check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure )
 14 | 
 15 | # Use C99.
 16 | set( CMAKE_C_STANDARD 99 )
 17 | set( CMAKE_C_STANDARD_REQUIRED ON )
 18 | 
 19 | # TODO: Move this to a separate CMake file specific encapsulating the build
 20 | if ( CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "GNU" )
 21 | 	SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Wall -Wextra -pedantic" )
 22 | endif()
 23 | 
 24 | # Do not allow in-source build.
 25 | if( ${PROJECT_SOURCE_DIR} STREQUAL ${PROJECT_BINARY_DIR} )
 26 |     message( FATAL_ERROR "In-source builds are not allowed. Please build in a separate directory, such as ${PROJECT_SOURCE_DIR}/../build." )
 27 | endif()
 28 | 
 29 | if(NOT AIA_CLIENT_SDK_DIR)
 30 |     set(AIA_CLIENT_SDK_DIR "${PROJECT_SOURCE_DIR}/external/AIAClientSDK")
 31 | endif()
 32 | 
 33 | include(${AIA_CLIENT_SDK_DIR}/cmake/Logging.cmake)
 34 | 
 35 | # Build for Amazon FreeRTOS
 36 | set(aia_core_dir "${AIA_CLIENT_SDK_DIR}/AiaCore")
 37 | set(aia_util_dir "${AIA_CLIENT_SDK_DIR}/ApplicationUtilities")
 38 | 
 39 | set(aia_afr_dir "${PROJECT_SOURCE_DIR}")
 40 | set(aia_afr_ports_dir "${aia_afr_dir}/ports")
 41 | set(aia_afr_demo_dir "${aia_afr_dir}/demos/aia")
 42 | set(aia_afr_util_dir "${aia_afr_demo_dir}/utils")
 43 | 
 44 | set(AIA_AFR_PORTS_FOLDER "${aia_afr_ports_dir}")
 45 | set(AIA_BUTTON_FOLDER "${AIA_AFR_PORTS_FOLDER}/Button")
 46 | set(AIA_CLOCK_FOLDER "${AIA_AFR_PORTS_FOLDER}/Clock")
 47 | set(AIA_COMMON_FOLDER "${AIA_AFR_PORTS_FOLDER}/Common")
 48 | set(AIA_CRYPTO_FOLDER "${AIA_AFR_PORTS_FOLDER}/Crypto")
 49 | set(AIA_HTTP_FOLDER "${AIA_AFR_PORTS_FOLDER}/HTTP")
 50 | set(AIA_IOT_FOLDER "${AIA_AFR_PORTS_FOLDER}/IoT")
 51 | set(AIA_LWA_FOLDER "${AIA_AFR_PORTS_FOLDER}/LWA")
 52 | set(AIA_MEMORY_FOLDER "${AIA_AFR_PORTS_FOLDER}/Memory")
 53 | set(AIA_MICROPHONE_FOLDER "${AIA_AFR_PORTS_FOLDER}/Microphone")
 54 | set(AIA_REGISTRATION_FOLDER "${AIA_AFR_PORTS_FOLDER}/Registration")
 55 | set(AIA_STORAGE_FOLDER "${AIA_AFR_PORTS_FOLDER}/Storage")
 56 | 
 57 | set(AIA_DEMO_AFR_AUDIO false CACHE BOOL "Enable Audio Demo for AFR Windows Simulator")
 58 | 
 59 | # Module - aia_interface
 60 | afr_module(NAME aia_interface)
 61 | 
 62 | afr_set_lib_metadata(ID "aia_interface")
 63 | afr_set_lib_metadata(DESCRIPTION "This library provides the interface to the AIA, which allows devices to retrive Alexa via MQTT.")
 64 | afr_set_lib_metadata(DISPLAY_NAME "aia_interface")
 65 | afr_set_lib_metadata(CATEGORY "AIA")
 66 | afr_set_lib_metadata(VERSION "1.0.0")
 67 | afr_set_lib_metadata(IS_VISIBLE "true")
 68 | 
 69 | afr_module_include_dirs(
 70 |     ${AFR_CURRENT_MODULE}
 71 |     PUBLIC
 72 |         "${aia_core_dir}/include"
 73 |         "${aia_afr_ports_dir}/include"
 74 |         "${AIA_BUTTON_FOLDER}/include"
 75 |         "${AIA_CLOCK_FOLDER}/include"
 76 |         "${AIA_CRYPTO_FOLDER}/include"
 77 |         "${AIA_IOT_FOLDER}/include"
 78 |         "${AIA_HTTP_FOLDER}/include"
 79 |         "${AIA_LWA_FOLDER}/include"
 80 |         "${AIA_MEMORY_FOLDER}/include"
 81 |         "${AIA_MICROPHONE_FOLDER}/include"
 82 |         "${AIA_REGISTRATION_FOLDER}/include"
 83 |         "${AIA_STORAGE_FOLDER}/include"
 84 |         "${AIA_COMMON_FOLDER}/include"
 85 | )
 86 | 
 87 | afr_module_sources(
 88 |     ${AFR_CURRENT_MODULE}
 89 |     PRIVATE
 90 |         "${AIA_CLOCK_FOLDER}/src/aia_clock_config.c"
 91 |         "${AIA_CRYPTO_FOLDER}/src/aia_crypto_config.c"
 92 |         "${AIA_STORAGE_FOLDER}/src/aia_storage_config.c"
 93 |         "${AIA_HTTP_FOLDER}/src/aia_http_config.c"
 94 |         "${AIA_IOT_FOLDER}/src/aia_iot_config.c"
 95 |         "${AIA_LWA_FOLDER}/src/aia_lwa_config.c"
 96 |         "${AIA_REGISTRATION_FOLDER}/src/aia_registration_config.c"
 97 | )
 98 | 
 99 | afr_module_dependencies(
100 |     ${AFR_CURRENT_MODULE}
101 |     PUBLIC
102 |         3rdparty::jsmn
103 |         3rdparty::mbedtls
104 |         AFR::mqtt
105 |         AFR::serializer
106 |         AFR::https
107 | )
108 | 
109 | # Module - 3rdparty_aia_core
110 | afr_module(NAME 3rdparty_aia_core)
111 | 
112 | afr_set_lib_metadata(ID "3rdparty_aia_core")
113 | afr_set_lib_metadata(DESCRIPTION "This is the core implementation of AIA")
114 | afr_set_lib_metadata(DISPLAY_NAME "3rdparty_aia_core")
115 | afr_set_lib_metadata(CATEGORY "AIA")
116 | afr_set_lib_metadata(VERSION "1.0.0")
117 | afr_set_lib_metadata(IS_VISIBLE "true")
118 | 
119 | afr_module_include_dirs(
120 |     ${AFR_CURRENT_MODULE}
121 |     PUBLIC
122 |         "${aia_core_dir}/include"
123 |         "${aia_afr_ports_dir}/include"
124 | )
125 | 
126 | file(GLOB_RECURSE aia_core_src_files "${aia_core_dir}/source/*/*.c")
127 | 
128 | afr_module_sources(
129 |     ${AFR_CURRENT_MODULE}
130 |     PRIVATE
131 |         ${aia_core_src_files}
132 | )
133 | 
134 | afr_module_dependencies(
135 |     ${AFR_CURRENT_MODULE}
136 |     PUBLIC
137 |         AFR::aia_interface
138 | )
139 | 
140 | # Module - aia_demo_utils
141 | afr_module(NAME aia_demo_utils)
142 | 
143 | afr_set_lib_metadata(ID "aia_demo_utils")
144 | afr_set_lib_metadata(DESCRIPTION "This is the application utilities of AIA")
145 | afr_set_lib_metadata(DISPLAY_NAME "aia_demo_utils")
146 | afr_set_lib_metadata(CATEGORY "AIA")
147 | afr_set_lib_metadata(VERSION "1.0.0")
148 | afr_set_lib_metadata(IS_VISIBLE "true")
149 | 
150 | afr_module_include_dirs(
151 |     ${AFR_CURRENT_MODULE}
152 |     PUBLIC
153 |         "${aia_util_dir}/aiaclient/include"
154 | )
155 | 
156 | afr_module_sources(
157 |     ${AFR_CURRENT_MODULE}
158 |     PRIVATE
159 |         "${aia_util_dir}/aiaclient/source/aia_client.c"
160 | )
161 | 
162 | afr_module_dependencies(
163 |     ${AFR_CURRENT_MODULE}
164 |     PUBLIC
165 |         AFR::3rdparty_aia_core
166 | )
167 | 
168 | # Module - aia_util with audio functionalities
169 | if ("${AIA_DEMO_AFR_AUDIO}")
170 |     if (NOT LIBOPUS_INCLUDE_DIR OR NOT LIBOPUS_LIB_PATH)
171 |         message( FATAL_ERROR "Missing libopus; Please specify -DLIBOPUS_INCLUDE_DIR and -DLIBOPUS_LIB_PATH" )
172 |     endif()
173 |     if (NOT PORTAUDIO_INCLUDE_DIR OR NOT PORTAUDIO_LIB_PATH)
174 |         message( FATAL_ERROR "Missing portaudio; Please specify -DPORTAUDIO_INCLUDE_DIR and -DPORTAUDIO_LIB_PATH" )
175 |     endif()
176 | 
177 |     afr_module_include_dirs(
178 |         ${AFR_CURRENT_MODULE}
179 |         PUBLIC
180 |             "${aia_util_dir}/aiaalerttonesynthesizer/include"
181 |             "${aia_util_dir}/aiaopusdecoder/include"
182 |             "${aia_util_dir}/aiaportaudiospeaker/include"
183 |             "${aia_afr_util_dir}/aiaportaudiomicrophone/include"
184 |             "${LIBOPUS_INCLUDE_DIR}"
185 |             "${PORTAUDIO_INCLUDE_DIR}"
186 |     )
187 | 
188 |     afr_module_sources(
189 |         ${AFR_CURRENT_MODULE}
190 |         PRIVATE
191 |             "${aia_util_dir}/aiaopusdecoder/source/aia_opus_decoder.c"
192 |             "${aia_util_dir}/aiaportaudiospeaker/source/aia_portaudio_speaker.c"
193 |             "${aia_afr_util_dir}/aiaportaudiomicrophone/source/aia_portaudio_microphone.c"
194 |     )
195 | 
196 |     if(TARGET aws_demos)
197 |         target_link_libraries( aws_demos PRIVATE "${LIBOPUS_LIB_PATH}" )
198 |         target_link_libraries( aws_demos PRIVATE "${PORTAUDIO_LIB_PATH}" )
199 |     endif()
200 | endif()
201 | 
202 | # Module aia_demo
203 | afr_demo_module(aia_demo)
204 | 
205 | afr_set_demo_metadata(ID "AIA_DEMO")
206 | afr_set_demo_metadata(DESCRIPTION "An example on how to use Alexa voice service via AWS IoT")
207 | afr_set_demo_metadata(DISPLAY_NAME "AIA for FreeRTOS")
208 | 
209 | afr_module_sources(
210 |     ${AFR_CURRENT_MODULE}
211 |     INTERFACE
212 |         "${aia_afr_demo_dir}/aia_sample_main.c"
213 |         "${aia_afr_demo_dir}/aia_sample_app.c"
214 | )
215 | 
216 | afr_module_dependencies(
217 |     ${AFR_CURRENT_MODULE}
218 |     INTERFACE
219 |         AFR::3rdparty_aia_core
220 |         AFR::aia_demo_utils
221 | )


--------------------------------------------------------------------------------
/ports/Storage/include/storage/aia_storage_config.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #ifndef AIA_STORAGE_CONFIG_H_
 18 | #ifdef __cplusplus
 19 | extern "C" {
 20 | #endif
 21 | #define AIA_STORAGE_CONFIG_H_
 22 | 
 23 | #include <clock/aia_clock_config.h>
 24 | 
 25 | #include <stdbool.h>
 26 | #include <stddef.h>
 27 | 
 28 | /**
 29 |  * @name Retrieval and persistent storage of generic blobs as key-value pairs.
 30 |  * Implementations are not required to be thread-safe. These functions are
 31 |  * required to be implemented. Implementations should be defined in @file
 32 |  * aia_storage_config.c
 33 |  */
 34 | /** @{ */
 35 | 
 36 | /**
 37 |  * Persists the given blob.
 38 |  *
 39 |  * @param key Null-terminated string to use as the key for this blob.
 40 |  * @param blob The buffer to persist.
 41 |  * @param size Size of @c blob.
 42 |  * @return @c true on success or @c false otherwise.
 43 |  */
 44 | bool AiaStoreBlob( const char* key, const uint8_t* blob, size_t size );
 45 | 
 46 | /**
 47 |  * Loads blob out of persistent storage.
 48 |  *
 49 |  * @param key Null-terminated string representing the key for the blob to load.
 50 |  * @param[out] blob The buffer to load.
 51 |  * @param size Size of @c blob.
 52 |  * @return @c true on success or @c false otherwise.
 53 |  */
 54 | bool AiaLoadBlob( const char* key, uint8_t* const blob, size_t size );
 55 | 
 56 | /**
 57 |  * Gets the size of the blob in persistent storage.
 58 |  *
 59 |  * @param key Null-terminated string to use as the key for the blob.
 60 |  * @return the length of data in bytes. @c 0 will be returned on failures.
 61 |  */
 62 | size_t AiaGetBlobSize( const char* key );
 63 | 
 64 | /**
 65 |  * Checks if a blob exists in persistent storage.
 66 |  *
 67 |  * @param key Null-terminated string to use as the key for the blob.
 68 |  * @return @c true if the blob exists of @c false otherwise.
 69 |  */
 70 | bool AiaBlobExists( const char* key );
 71 | 
 72 | /** @} */
 73 | 
 74 | /**
 75 |  * @name Retrieval and persistent storage of shared secret used for end-to-end
 76 |  * encryption. Storage will be used during registration and secret rotation and
 77 |  * loading will be used during AIA SDK startup. Implementations are not required
 78 |  * to be thread-safe. These functions are required to be implemented.
 79 |  * Implementations should be defined in @file aia_config.c
 80 |  */
 81 | /** @{ */
 82 | 
 83 | /**
 84 |  * Persists the given secret.
 85 |  *
 86 |  * @param sharedSecret The buffer to persist.
 87 |  * @param size Size of @c sharedSecret. Note that this should be @c
 88 |  * AiaEncryptionAlgorithm_GetKeySize() of the encryption algorithm defined in
 89 |  * @file aia_registration_config.h.
 90 |  * @return @c true on success or @c false otherwise.
 91 |  */
 92 | bool AiaStoreSecret( const uint8_t* sharedSecret, size_t size );
 93 | 
 94 | /**
 95 |  * Loads shared secret out of persistent storage.
 96 |  *
 97 |  * @param[out] sharedSecret The buffer to load into.
 98 |  * @param size Size of the @c sharedSecret buffer.
 99 |  * @return @c true on success or @c false otherwise.
100 |  */
101 | bool AiaLoadSecret( uint8_t* sharedSecret, size_t size );
102 | 
103 | /** @} */
104 | 
105 | /**
106 |  * @name Retrieval of local volume. Implementations are not required to
107 |  * be thread-safe. These functions are optional and only required if the device
108 |  * persists volume locally or allows for local offline changes to volume. AIA
109 |  * will use a cached server-side volume if @c AIA_LOAD_VOLUME is not defined. If
110 |  * not desired, delete the below portion.
111 |  */
112 | /** @{ */
113 | 
114 | /**
115 |  * This function is used to load persisted volume for use during
116 |  * synchronizing of device state upon a fresh AIA connection.
117 |  *
118 |  * @return @c The loaded volume. Any failure shall return @c AIA_DEFAULT_VOLUME.
119 |  */
120 | uint8_t AiaLoadVolume();
121 | 
122 | #define AIA_LOAD_VOLUME AiaLoadVolume
123 | 
124 | /** @} */
125 | 
126 | /**
127 |  * @name Retrieval and persistent storage of AIA alerts (timers, reminders,
128 |  * alarms). Storage will be used when an alert is created, updated or deleted.
129 |  * Loading will be used before adding, updating or deleting an alert or during
130 |  * AIA SDK startup. Implementations are not required to be thread-safe. These
131 |  * functions are required to be implemented. Implementations should be defined
132 |  * in @file aia_config.c.
133 |  */
134 | /** @{ */
135 | 
136 | /**
137 |  * Removes a given alert from persistent storage.
138 |  *
139 |  * @param alertToken The alert token to remove not including the null
140 |  * terminator.
141 |  * @param alertTokenLen Length of @c alertToken not including the null
142 |  * terminator.
143 |  * @note @c alertTokenLen is expected to be equal to @c AIA_ALERT_TOKEN_CHARS
144 |  * for persistent storage consistency.
145 |  * @return @c true on success of @c false otherwise.
146 |  */
147 | bool AiaDeleteAlert( const char* alertToken, size_t alertTokenLen );
148 | 
149 | /**
150 |  * Serializes the given alert fields and persists the serialized blob.
151 |  *
152 |  * @param alertToken The alert token to persist not including the null
153 |  * terminator.
154 |  * @param alertTokenLen Length of @c alertToken not including the null
155 |  * terminator.
156 |  * @param scheduledTime The alert scheduled time to persist.
157 |  * @param duration The alert duration to persist.
158 |  * @param alertType The alert type to persist.
159 |  * @return @c true on success or @c false otherwise.
160 |  *
161 |  * @note The format the alerts tokens are stored in the persistent storage (i.e.
162 |  * little endian byte ordering) needs to match with the format the alerts are
163 |  * retrieved from the persistent storage (@c AiaLoadAlert()).
164 |  * @note @c alertTokenLen is expected to be equal to @c AIA_ALERT_TOKEN_CHARS
165 |  * for persistent storage consistency.
166 |  */
167 | bool AiaStoreAlert( const char* alertToken, size_t alertTokenLen,
168 |                     AiaTimepointSeconds_t scheduledTime,
169 |                     AiaDurationMs_t duration, uint8_t alertType );
170 | 
171 | /**
172 |  * Deserializes the alert fields starting from the given buffer location.
173 |  *
174 |  * @param[out] alertToken Pointer to the buffer to hold the alert token not
175 |  * including the null terminator.
176 |  * @param alertTokenLen Length of @c alertToken not including the null
177 |  * terminator.
178 |  * @param[out] scheduledTime Pointer to the buffer to hold the scheduled time.
179 |  * @param[out] duration Pointer to the buffer to hold the duration.
180 |  * @param[out] alertType Pointer to the buffer to hold the alertType.
181 |  * @param allAlertsBuffer Pointer to the buffer to start reading alert
182 |  * information from.
183 |  * @return @c true on success or @c false otherwise.
184 |  *
185 |  * @note The format the alerts tokens are loaded from the persistent storage
186 |  * (i.e. little endian byte ordering) needs to match with the format the alerts
187 |  * are stored in the persistent storage (@c AiaStoreAlert()).
188 |  * @note The @c allAlertsBuffer parameter points to a section of the alerts blob
189 |  * loaded via the @c AiaLoadAlerts() function which splits the alerts blob into
190 |  * sections of @c AIA_SIZE_OF_ALERT_IN_BYTES bytes.
191 |  * @note @c alertTokenLen is expected to be equal to @c AIA_ALERT_TOKEN_CHARS
192 |  * for persistent storage consistency.
193 |  */
194 | bool AiaLoadAlert( char* alertToken, size_t alertTokenLen,
195 |                    AiaTimepointSeconds_t* scheduledTime,
196 |                    AiaDurationMs_t* duration, uint8_t* alertType,
197 |                    const uint8_t* allAlertsBuffer );
198 | 
199 | /**
200 |  * Loads alerts out of persistent storage if an alerts blob exists in persistent
201 |  * storage.
202 |  *
203 |  * @param[out] allAlerts Buffer to hold the loaded alerts.
204 |  * @param size Size of the @c allAlerts buffer.
205 |  * @return @c true on success or if the alerts blob does not exist,
206 |  * and @c false otherwise.
207 |  */
208 | bool AiaLoadAlerts( uint8_t* allAlerts, size_t size );
209 | 
210 | /**
211 |  * Gets the size of the alerts blob in persistent storage.
212 |  *
213 |  * @return the length of alerts blob in bytes. @c 0 will be returned on
214 |  * failures or if the alerts blob does not exist.
215 |  */
216 | size_t AiaGetAlertsSize();
217 | 
218 | /**
219 |  * Checks if an alerts blob exists in the persistent storage or not.
220 |  *
221 |  * @return @c true if the blob exists or @c false otherwise.
222 |  */
223 | bool AiaAlertsBlobExists();
224 | 
225 | #ifdef __cplusplus
226 | }
227 | #endif
228 | #endif /* ifndef AIA_STORAGE_CONFIG_H_ */
229 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # AIA Client SDK Integration with FreeRTOS #
  2 | 
  3 | > This project is a port of the AIA Client SDK to FreeRTOS. AIA stands for Alexa Voice Service Integration for AWS IoT.
  4 | 
  5 | A complete implementation, including implementation of the porting layer on FreeRTOS, and a demo application that performs AIA registration and Alexa interactions, is provided for the Windows Simulator target of FreeRTOS.  You can use it as a template for porting to embedded hardware platforms of FreeRTOS.
  6 | 
  7 | ![Aia_Client_SDK_AFR_Integration_source_tree](images/apal_afr_integration_source_tree.png)
  8 | 
  9 | ## How to get the code ##
 10 | 
 11 | In order to build a complete executable, you will need three components, shown in the chart above.
 12 | 
 13 | 1. **FreeRTOS**: This is the official FreeRTOS IoT Reference Integration package. You can download it from [AWS GitHub](https://github.com/aws/amazon-freertos).
 14 | 2. **AIA Porting Layer**: This is the project you are looking at right now. Download this project and place it under the libraries folder of FreeRTOS. It does not contain the AIA Client SDK, but when you clone this project, Git helps to download the AIA Client SDK as a sub-module.
 15 | 
 16 | 3. **AIA Client SDK**: The SDK implements AIA protocols and core functions.
 17 | 
 18 | ## Get a refresh token ##
 19 | 
 20 | > Before you can build and run, you need to register with AVS and obtain a refresh token.
 21 | 
 22 | 1. You need an Amazon Developer Account at <https://developer.amazon.com/>
 23 | 2. Create an **AVS product ID** and **AVS client ID** by following the instruction [here](https://developer.amazon.com/en-US/docs/alexa/alexa-voice-service/code-based-linking-other-platforms.html#step1).
 24 | 3. Find your **AVS product ID** and **AVS client ID** from the AVS console
 25 |    * **AVS client ID** is in AVS console → Security Profile → Other devices and platforms
 26 | 4. Get **user code** and **device code** by curl
 27 |    * Replace **AVS_CLIENT_ID** and **AVS_PRODUCT_ID** in the command below
 28 |    * Define a unique ID as your device serial number, use it in place of the *YOUR_DSN*
 29 | 
 30 |         ```sh
 31 |         curl -k -d'response_type=device_code&client_id=AVS_CLIENT_ID&scope=alexa%3Aall&scope_data=%7B%22alexa%3Aall%22%3A%7B%22productID%22%3A%22AVS_PRODUCT_ID%22,%22productInstanceAttributes%22%3A%7B%22deviceSerialNumber%22%3A%22YOUR_DSN%22%7D%7D%7D'-H"Content-Type: application/x-www-form-urlencoded" -X POST https://api.amazon.com/auth/O2/create/codepair
 32 |         ```
 33 | 
 34 |    * You will get **USER_CODE** and **DEVICE_CODE** from the response.
 35 | 
 36 | 5. Sign into <https://amazon.com/us/code>, fill in the **USER_CODE** returned by previous command
 37 | 6. Get **refresh token** by curl
 38 |     * Replace the **DEVICE_CODE** and **USER_CODE** in the command below
 39 |     * You will get a **REFRESH_TOKEN** from the response
 40 | 
 41 |         ```sh
 42 |         curl 'https://api.amazon.com/auth/O2/token' -H "Content-Type: application/x-www-form-urlencoded" -X POST -d 'grant_type=device_code&device_code=DEVICE_CODE&user_code=USER_CODE'
 43 |         ```
 44 | 
 45 | ## How to build ##
 46 | 
 47 | 1. Download *FreeRTOS* from [GitHub](https://github.com/aws/amazon-freertos). The latest version of this project has been integrated with version **`202007.00`**.
 48 | 2. Put the content of this project under the $AFR_SRC_DIR/libraries/freertos_plus/aws/aia directory
 49 | 
 50 |     ```sh
 51 |     cd $AFR_SRC_DIR/libraries/freertos_plus/aws
 52 |     git clone $AIA_PORTING_LAYER_GIT_REPO_URI aia --recurse-submodules
 53 |     ```
 54 | 
 55 | 3. The **[AIA Client SDK](https://github.com/alexa/AIAClientSDK)** is downloaded automatically under $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/external/AIAClientSDK
 56 |     * If you have the AIA Client SDK in another folder, you can specify the path by using **-DAIA_CLIENT_SDK_DIR=YOUR_SDK_PATH** in CMake
 57 | 4. At the current versions, there are some modifications needed in both the AIA Client SDK and FreeRTOS in order to make them work together. We are working with the SDK team and FreeRTOS team to upstream the needed changes. For now, please apply patches using the commands below.
 58 |    * Patch Freertos
 59 | 
 60 |         ```sh
 61 |         cd $AFR_SRC_DIR
 62 |         git apply $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/patch/freertos_20200700_4e8219e0.patch
 63 |         ```
 64 | 
 65 |    * Patch the AIA Client SDK
 66 | 
 67 |         ```sh
 68 |         cd $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/external/AIAClientSDK
 69 |         git apply $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/patch/AiaClientSDK_0deab3e0.patch
 70 |         ```
 71 | 
 72 | 5. Configure AWS IoT for FreeRTOS Demos
 73 |    * Fill credential information in $AFR_SRC_DIR/demos/include/aws_clientcredential.h and $AFR_SRC_DIR/demos/include/aws_clientcredential_keys.h
 74 | 
 75 | 6. Build FreeRTOS for the selected target.
 76 |     * Config Log-In with Amazon (LWA) for registration.
 77 |       * Modify **$AFR_SRC_DIR/libraries/freertos_plus/aws/aia/demos/aia/aia_sample_app.c**
 78 |         * Fill your AWS account ID in **AIA_REG_HTTPS_AWS_ACCOUNT_ID**
 79 |         * Fill your AVS client ID in **AIA_REG_HTTPS_LWA_CLIENT_ID** *(obtained in step #3 of **Authenticate by Code-Based Linking** session above)*
 80 |         * Fill your LWA refresh token in **AIA_REG_HTTPS_LWA_REFRESH_TOKEN** *(obtained in step #6 of **Authenticate by Code-Based Linking** session) above*
 81 |       * Select to build AIA demo by editing **$AFR_SRC_DIR/vendors/pc/boards/windows/aws_demos/config_files/aws_demo_config.h**
 82 |         * Enable AIA demo by **#define CONFIG_AIA_DEMO_ENABLED**
 83 |     * Build the Windows Simulator target.
 84 |       * Prepare the requirements for build Windows simulator.
 85 |         * **CMake** for Windows
 86 |         * **Microsoft Visual Studio** 2019
 87 |         * **LLVM (clang-cl)**: You can get it from Microsoft Visual Studio installer program.
 88 |       * Follow the [tutorial](https://docs.aws.amazon.com/freertos/latest/userguide/getting_started_windows.html) to build FreeRTOS Windows simulator.
 89 |         * Please follow **Building and running the FreeRTOS demo project with CMake** session of the tutorial.
 90 |         * Because the AIA Client SDK requires C99 support, select **LLVM (clang-cl)** as the platform toolset for **afr_3rdparty_aia_core** and **afr_aia_demo_utils** projects in Microsoft Visual Studio.
 91 |         * If you have the problem of `'_serialize': intrinsic function, cannot be defined` when building **afr_defender**, please also select **LLVM (clang-cl)** as the platform toolset for **afr_defender**.
 92 |       * *(Optional)* If you want to `build microphone/speaker audio functionalities` for the demo app on Windows simulator:
 93 |         * The demo app on Windows Simulator uses **[PortAudio](http://www.portaudio.com/archives/pa_stable_v190600_20161030.tgz)** and **[Opus](https://github.com/xiph/opus)**. For embedded target platforms, those will be replaced by the Audio Common I/O interface of FreeRTOS.
 94 |         * Set a bool value **-DAIA_DEMO_AFR_AUDIO=true** in CMake entry to enable audio
 95 |           * Build static libraries for both PortAudio and Opus on your Windows platform
 96 |           * Specify include path and libraries path for CMake entry
 97 |             * **-DLIBOPUS_INCLUDE_DIR**=path_to_libopus_include_directory
 98 |             * **-DLIBOPUS_LIB_PATH**=path_to_opus.lib_that_is_built_by_you
 99 |             * **-DPORTAUDIO_INCLUDE_DIR**=path_to_portaudio_include_directory
100 |             * **-DPORTAUDIO_LIB_PATH**=path_to_portaudio.lib_(static)_that_is_built_by_you
101 |         * If you want to `run audio demo cases`, please un-comment **#define AIA_DEMO_AUDIO_ENABLE** in $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/demos/aia/aia_sample_app.c
102 |           * At run time, you can talk with Alexa when seeing **Start to talk** on console output.
103 |           * The sample app runs a sequential flow to demonstrate microphone hold-to-talk.
104 |           * The program will wait 2.5 seconds for user to start talking.
105 |           * The program will wait 7 seconds for AVS response.
106 |     * Build embedded targets
107 |       * Change directory into $AFR_SRC_DIR/libraries/freertos_plus/aws/aia/ports folder and make modifications for the specific target.
108 |         * **Button**: Current sample does not use buttons. Implement it if your target supports buttons.
109 |         * **Clock**:This project provides an implementation that stores and prints time information.
110 |         * **Common**: This project uses FreeRTOS ASSERT(0).
111 |         * **Crypto**: The default implementation depends on mbedTLS.
112 |         * **HTTP**: This project uses the HTTP library provided by FreeRTOS.
113 |         * **include**: Configurations of AIA capabilities, buffer size, etc.
114 |         * **IoT**: MQTT operations to communicate with AWS IoT Core. This project uses the MQTT library provided by FreeRTOS.
115 |         * **LWA**: APIs to load and store LWA tokens. This project’s implementation keeps LWA information in global variables, change it if you have different mechanisms.
116 |         * **Memory**: This project implements memory operations using FreeRTOS interfaces.
117 |         * **Registration**: This project implements operation for loading registration information. Change it if you have a different mechanisms.
118 |         * **Storage**: This project implements the storage used by AIA in DRAM.  Change it when you port to an embedded target.
119 |       * Integrate audio functionalities
120 |         * Integrate an OPUS audio codec your choice.
121 |         * Implement microphone and speaker drivers for your platform.
122 |         * Change the implementation of AIA sample app from PortAudio/Libopus to the one that uses your microphone and speaker drivers.
123 |       * You can also read the AIA Client SDK [README](https://github.com/alexa/AIAClientSDK/blob/master/README.md) and [Porting Guide](https://github.com/alexa/AIAClientSDK/blob/master/PortingGuide.md) for more details.
124 | 


--------------------------------------------------------------------------------
/ports/include/aia_application_config.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_application_config.h
 19 |  * @brief APIs required to be implemented by the end application.
 20 |  */
 21 | 
 22 | #ifndef AIA_APPLICATION_CONFIG_H_
 23 | #define AIA_APPLICATION_CONFIG_H_
 24 | 
 25 | #include <aia_config.h>
 26 | 
 27 | /* AIA Capabilities Config */
 28 | #include <aia_capabilities_config.h>
 29 | 
 30 | #include <aiaalertmanager/aia_alert_slot.h>
 31 | #include <aiaconnectionmanager/aia_connection_constants.h>
 32 | #include <aiacore/capabilities_sender/aia_capabilities_sender_state.h>
 33 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer.h>
 34 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer_writer.h>
 35 | #include <aiaexceptionmanager/aia_exception_code.h>
 36 | #include <aiauxmanager/aia_ux_state.h>
 37 | 
 38 | /* TODO: ADSER-1920 Move all of these into aia_config.h into simple functions
 39 |  * rather than callbacks such that failures to define them will result in a
 40 |  * compilation error. */
 41 | /**
 42 |  * The following are functions expected to be implemented by the end
 43 |  * application. Most are required parameters for creation of the @c AiaClient
 44 |  * object.
 45 |  */
 46 | /** @{ */
 47 | 
 48 | /**
 49 |  * This callback is invoked after the client is successfully connected to
 50 |  * the service upon a call to @c AiaClient_Connect. Implementations are
 51 |  * expected to be non-blocking and are not required to be thread-safe.
 52 |  *
 53 |  * @param userData Optional user data pointer which was provided alongside the
 54 |  * callback.
 55 |  */
 56 | typedef void ( *AiaConnectionManageronConnectionSuccessCallback_t )(
 57 |     void* userData );
 58 | 
 59 | /**
 60 |  * This callback function is invoked after the client is disconnected from the
 61 |  * service. This can occur upon reception of a server initiated disconnection or
 62 |  * upon a call to @c AiaClient_Disconnect(). Implementations are expected to be
 63 |  * non-blocking and are not required to be thread-safe.
 64 |  *
 65 |  * @param userData Optional user data pointer which was provided alongside the
 66 |  * callback.
 67 |  * @param code The Connection Disconnect Message code received by the client.
 68 |  */
 69 | typedef void ( *AiaConnectionManagerOnDisconnectedCallback_t )(
 70 |     void* userData, AiaConnectionOnDisconnectCode_t code );
 71 | 
 72 | /**
 73 |  * This callback function is used after the client receives a unsuccessful
 74 |  * Connection Acknowledgement message upon a call to @c AiaClient_Connect.
 75 |  * Implementations are expected to be non-blocking and are not required to be
 76 |  * thread-safe.
 77 |  *
 78 |  * @param userData Optional user data pointer which was provided alongside the
 79 |  * callback.
 80 |  * @param code The Connection Acknowledge Message code received by the client.
 81 |  */
 82 | typedef void ( *AiaConnectionManagerOnConnectionRejectionCallback_t )(
 83 |     void* userData, AiaConnectionOnConnectionRejectionCode_t code );
 84 | 
 85 | /**
 86 |  * This callback is invoked after an Exception directive is received from the
 87 |  * service. Implementations are expected to be non-blocking and are not required
 88 |  * to be thread-safe.
 89 |  * @note This may be helpful for applications that want to implement some sort
 90 |  * of watchdog logic.
 91 |  *
 92 |  * @param userData Optional user data pointer which was provided alongside the
 93 |  * callback.
 94 |  * @param code The Exception message code received by the client.
 95 |  */
 96 | typedef void ( *AiaExceptionManagerOnExceptionCallback_t )(
 97 |     void* userData, AiaExceptionCode_t code );
 98 | 
 99 | /**
100 |  * This function allows clients to observe the state of the @c
101 |  * AiaCapabilitiesSender_t and published capabilities upon a call to @c
102 |  * AiaClient_PublishCapabilities.
103 |  *
104 |  * @param state The state of capabilities publishing.
105 |  * @param description The description message provided by the Aia service
106 |  * when acknowledging published capabilities. Note that this field will only be
107 |  * valid when @c state is @c AIA_CAPABILITIES_STATE_REJECTED and that this field
108 |  * is optional and may be @c NULL.
109 |  * @param descriptionLen The length of @c description, not including a null
110 |  * terminating character.
111 |  * @param userData Context associated with this callback.
112 |  * @note Calling back into the @c AiaClient_t from within the
113 |  * same execution context of this callback will result in a deadlock.
114 |  */
115 | typedef void ( *AiaCapabilitiesObserver_t )( AiaCapabilitiesSenderState_t state,
116 |                                              const char* description,
117 |                                              size_t descriptionLen,
118 |                                              void* userData );
119 | 
120 | /**
121 |  * This function will be invoked to notify of @c AiaUXState_t changes.
122 |  * Implementations are expected to be non-blocking and are not required to be
123 |  * thread-safe.
124 |  *
125 |  * @param state The new UX state to display to the end user.
126 |  * @param userData Context to be passed with this callback.
127 |  * @note Calling back into the @c AiaClient_t from within the same
128 |  * execution context of this callback will result in a deadlock.
129 |  */
130 | typedef void ( *AiaUXStateObserverCb_t )( AiaUXState_t state, void* userData );
131 | 
132 | /**
133 |  * This function is used to push data from an internal stream to the platform
134 |  * for playback every @c AIA_SPEAKER_FRAME_PUSH_CADENCE_MS. Implementations are
135 |  * expected to be non-blocking and are not required to be thread-safe.
136 |  *
137 |  * @param buf A buffer containing the data to play to be copied.
138 |  * @param size The number of bytes to play.
139 |  * @param userData User data associated with this callback.
140 |  *
141 |  * @return @c true if the frame was accepted or @c false if the frame could not
142 |  * be buffered.
143 |  * @note In the current implementation, a single frame is pushed per
144 |  * invocation.
145 |  * @note If @c false is returned, this callback will not be called again until
146 |  * notified to again via @c AiaClient_OnSpeakerReady() is called.
147 |  * @note Calling back into the @c AiaClient_t from within the same
148 |  * execution context of this callback will result in a deadlock.
149 |  */
150 | typedef bool ( *AiaPlaySpeakerData_t )( const void* buf, size_t size,
151 |                                         void* userData );
152 | 
153 | /**
154 |  * This function is used to change the speaker's volume. Implementations are
155 |  * expected to be non-blocking and are not required to be thread-safe.
156 |  *
157 |  * @param volume The new absolute volume. This value will fall between @c
158 |  * AIA_MIN_VOLUME and @c AIA_MAX_VOLUME, inclusive.
159 |  * @param userData User data associated with this callback.
160 |  * @warning Calling back into the @c AiaClient_t from within the same
161 |  * execution context of this callback will result in a deadlock.
162 |  * @note Implementations are expected to scale the volume level logarithmically
163 |  * to account for human sound level perception of loudness (i.e. decibel).
164 |  */
165 | typedef void ( *AiaSetVolume_t )( uint8_t volume, void* userData );
166 | 
167 | /**
168 |  * Callback that starts the offline alert playback routine. Implementations are
169 |  * expected to be non-blocking and are not required to be thread-safe.
170 |  *
171 |  * @param offlineAlert The offline alert to synthesize an alert tone for.
172 |  * @param userData User data associated with this callback.
173 |  * @return @c true If offline alert playback has successfully started or @c
174 |  * false otherwise.
175 |  * @note Only one offline alert at a time will be played with this callback. If
176 |  * there is already an offline alert being played, subsequent calls to this
177 |  * callback will be no-ops.
178 |  * @note @c offlineAlert will not be valid after the lifecycle of this callback,
179 |  * any data needed in it should be copied out.
180 |  */
181 | typedef bool ( *AiaOfflineAlertPlayback_t )( const AiaAlertSlot_t* offlineAlert,
182 |                                              void* userData );
183 | 
184 | /**
185 |  * Callback that disables offline alert playback. Implementations are expected
186 |  * to be non-blocking and are not required to be thread-safe.
187 |  *
188 |  * @param userData User data associated with this callback.
189 |  *
190 |  * @return @c true If offline alert playback has been disabled successfully or
191 |  * @c false otherwise.
192 |  */
193 | typedef bool ( *AiaOfflineAlertStop_t )( void* userData );
194 | 
195 | /**
196 |  * This is the shared buffer from which the SDK will consume microphone data
197 |  * captured by the device. The device is expected to capture and write
198 |  * microphone data into this buffer using an @c AiaMicrophoneBufferWriter_t.
199 |  * Data contained in the underlying buffer must be in 16-bit linear PCM, 16-kHz
200 |  * sample rate, single channel, little-endian byte order format.
201 |  */
202 | typedef AiaDataStreamBuffer_t AiaMicrophoneBuffer_t;
203 | 
204 | /**
205 |  * This is the writer object that applications are expected to use to write data
206 |  * into the @c AiaMicrophoneBuffer_t.
207 |  */
208 | typedef AiaDataStreamWriter_t AiaMicrophoneBufferWriter_t;
209 | 
210 | /** @} */
211 | 
212 | #endif /* ifndef AIA_APPLICATION_CONFIG_H_ */
213 | 


--------------------------------------------------------------------------------
/demos/aia/utils/aiaportaudiomicrophone/source/aia_portaudio_microphone.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_portaudio_microphone.c
 19 |  * @brief Reference implementation of a microphone recorder using PortAudio.
 20 |  */
 21 | 
 22 | /* The config header is always included first. */
 23 | #include <aia_config.h>
 24 | 
 25 | #include <aiaportaudiomicrophone/aia_portaudio_microphone.h>
 26 | 
 27 | #include <aiamicrophonemanager/aia_microphone_constants.h>
 28 | 
 29 | #include AiaMutex( HEADER )
 30 | #include AiaTimer( HEADER )
 31 | 
 32 | /** Number of channels format of microphone data. */
 33 | static const int NUM_INPUT_CHANNELS = 1;
 34 | 
 35 | /** Not playing back anything in this component, so no output channels. */
 36 | static const int NUM_OUTPUT_CHANNELS = 0;
 37 | 
 38 | /** Sample rate to record at. */
 39 | static const double SAMPLE_RATE = 16000;
 40 | 
 41 | /**
 42 |  * Called by a @c AiaPortAudioMicrophoneRecorder_t's @c captureMicrophoneTimer
 43 |  * to capture and write available microphone data to the underlying buffer.
 44 |  * This task runs at a @c MICROPHONE_PUBLISH_RATE / 4 cadence (arbitrary / needs
 45 |  * tuning).
 46 |  *
 47 |  * @param userData Pointer to the @c AiaPortAudioMicrophoneRecorder_t to act on.
 48 |  */
 49 | static void AiaPortAudioMicrophoneRecorder_MicrophoneCaptureTask(
 50 |     void* userData );
 51 | 
 52 | /**
 53 |  * A thin wrapper around PortAudio used for recording microphone data.
 54 |  */
 55 | struct AiaPortAudioMicrophoneRecorder
 56 | {
 57 |     /** The writer that will be used to write audio data into an @c
 58 |      * AiaDataStreamBuffer_t. */
 59 |     AiaDataStreamWriter_t* bufferWriter;
 60 | 
 61 |     /** Mutex used to guard against asynchronous calls in threaded
 62 |      * environments. */
 63 |     AiaMutex_t mutex;
 64 | 
 65 |     /** @name Variables synchronized by mutex. */
 66 |     /** @{ */
 67 | 
 68 |     /** The PortAudio stream. */
 69 |     PaStream* paStream;
 70 | 
 71 |     /** @} */
 72 | 
 73 |     /** Timer used to periodically capture and write available microphone data.
 74 |      */
 75 |     AiaTimer_t captureMicrophoneTimer;
 76 | 
 77 |     /** Flag used check if timer is created.
 78 |      */
 79 |     bool captureMicrophoneTimerExisted;
 80 | };
 81 | 
 82 | AiaPortAudioMicrophoneRecorder_t* AiaPortAudioMicrophoneRecorder_Create(
 83 |     AiaDataStreamWriter_t* bufferWriter )
 84 | {
 85 |     if( !bufferWriter )
 86 |     {
 87 |         AiaLogError( "Null bufferWriter" );
 88 |         return NULL;
 89 |     }
 90 | 
 91 |     size_t wordSize = AiaDataStreamWriter_GetWordSize( bufferWriter );
 92 | 
 93 |     if( wordSize != AIA_MICROPHONE_BUFFER_WORD_SIZE )
 94 |     {
 95 |         AiaLogError( "Invalid word size, expected=%zu, received=%zu",
 96 |                      AIA_MICROPHONE_BUFFER_WORD_SIZE, wordSize );
 97 |         return NULL;
 98 |     }
 99 | 
100 |     PaError err;
101 |     err = Pa_Initialize();
102 |     if( err != paNoError )
103 |     {
104 |         AiaLogError( "Failed to initialize PortAudio, errorCode=%s",
105 |                      Pa_GetErrorText( err ) );
106 |         return NULL;
107 |     }
108 | 
109 |     AiaPortAudioMicrophoneRecorder_t* recorder =
110 |         AiaCalloc( 1, sizeof( AiaPortAudioMicrophoneRecorder_t ) );
111 |     if( !recorder )
112 |     {
113 |         AiaLogError( "AiaCalloc failed, bytes=%zu",
114 |                      sizeof( AiaPortAudioMicrophoneRecorder_t ) );
115 |         Pa_Terminate();
116 |         return NULL;
117 |     }
118 | 
119 |     if( !AiaMutex( Create )( &recorder->mutex, false ) )
120 |     {
121 |         AiaLogError( "AiaMutex( Create ) failed." );
122 |         AiaFree( recorder );
123 |         Pa_Terminate();
124 |         return NULL;
125 |     }
126 | 
127 |     recorder->bufferWriter = bufferWriter;
128 | 
129 |     err = Pa_OpenDefaultStream( &recorder->paStream, NUM_INPUT_CHANNELS,
130 |                                 NUM_OUTPUT_CHANNELS, paInt16, SAMPLE_RATE,
131 |                                 paFramesPerBufferUnspecified, NULL, NULL );
132 |     if( err != paNoError )
133 |     {
134 |         AiaLogError( "Failed to open PortAudio default stream, errorCode=%s",
135 |                      Pa_GetErrorText( err ) );
136 |         AiaMutex( Destroy )( &recorder->mutex );
137 |         AiaFree( recorder );
138 |         Pa_Terminate();
139 |         return NULL;
140 |     }
141 | 
142 |     recorder->captureMicrophoneTimerExisted = false;
143 | 
144 |     return recorder;
145 | }
146 | 
147 | void AiaPortAudioMicrophoneRecorder_Destroy(
148 |     AiaPortAudioMicrophoneRecorder_t* recorder )
149 | {
150 |     AiaAssert( recorder );
151 |     if( !recorder )
152 |     {
153 |         AiaLogError( "Null recorder" );
154 |         return;
155 |     }
156 | 
157 |     if( recorder->captureMicrophoneTimerExisted )
158 |     {
159 |         AiaTimer( Destroy )( &recorder->captureMicrophoneTimer );
160 |         recorder->captureMicrophoneTimerExisted = false;
161 |     }
162 | 
163 |     AiaMutex( Lock )( &recorder->mutex );
164 |     Pa_CloseStream( recorder->paStream );
165 |     AiaMutex( Unlock )( &recorder->mutex );
166 | 
167 |     Pa_Terminate();
168 |     AiaMutex( Destroy )( &recorder->mutex );
169 |     AiaFree( recorder );
170 | }
171 | 
172 | void AiaPortAudioMicrophoneRecorder_MicrophoneCaptureTask( void* userData )
173 | {
174 |     AiaPortAudioMicrophoneRecorder_t* recorder =
175 |         (AiaPortAudioMicrophoneRecorder_t*)userData;
176 |     AiaAssert( recorder );
177 |     if( !recorder )
178 |     {
179 |         AiaLogError( "Null recorder" );
180 |         return;
181 |     }
182 | 
183 |     AiaMutex( Lock )( &recorder->mutex );
184 | 
185 |     /* Get number of frames that can be read without blocking. */
186 |     signed long numFramesAvailableToRead =
187 |         Pa_GetStreamReadAvailable( recorder->paStream );
188 |     if( numFramesAvailableToRead <= 0 )
189 |     {
190 |         if( numFramesAvailableToRead < 0 )
191 |         {
192 |             AiaLogError( "Pa_GetStreamReadAvailable failed, error=%ld",
193 |                          numFramesAvailableToRead );
194 |         }
195 |         AiaMutex( Unlock )( &recorder->mutex );
196 |         return;
197 |     }
198 | 
199 |     if( Pa_IsStreamActive(recorder->paStream) <= 0)
200 |     {
201 |         AiaLogWarn( "Pa_ReadStream is not active" );
202 |         AiaMutex( Unlock )( &recorder->mutex );
203 |         return;
204 |     }
205 | 
206 |     /* TODO: ADSER-1692 Double copy here, optimize. */
207 |     int16_t buf[ numFramesAvailableToRead ];
208 |     PaError err =
209 |         Pa_ReadStream( recorder->paStream, buf, numFramesAvailableToRead );
210 |     AiaMutex( Unlock )( &recorder->mutex );
211 |     if( err != paNoError )
212 |     {
213 |         if( err != paInputOverflowed )
214 |         {
215 |             AiaLogError( "Pa_ReadStream failed, errorCode=%s",
216 |                          Pa_GetErrorText( err ) );
217 |             return;
218 |         }
219 |         else
220 |         {
221 |             AiaLogWarn( "Input overflowed and discarded from previous call" );
222 |         }
223 |     }
224 | 
225 |     ssize_t writeReturnCode = AiaDataStreamWriter_Write(
226 |         recorder->bufferWriter, buf, numFramesAvailableToRead );
227 |     if( writeReturnCode <= 0 )
228 |     {
229 |         AiaLogError( "Failed to write to stream, error=%s",
230 |                      AiaDataStreamWriter_ErrorToString( writeReturnCode ) );
231 |         return;
232 |     }
233 | }
234 | 
235 | bool AiaPortAudioMicrophoneRecorder_StartStreamingMicrophoneData(
236 |     AiaPortAudioMicrophoneRecorder_t* recorder )
237 | {
238 |     AiaAssert( recorder );
239 |     if( !recorder )
240 |     {
241 |         AiaLogError( "Null recorder" );
242 |         return false;
243 |     }
244 | 
245 |     if( !AiaTimer( Create )(
246 |             &recorder->captureMicrophoneTimer,
247 |             AiaPortAudioMicrophoneRecorder_MicrophoneCaptureTask, recorder ) )
248 |     {
249 |         AiaLogError( "Failed to create captureMicrophoneTimer" );
250 |         return false;
251 |     }
252 |     recorder->captureMicrophoneTimerExisted = true;
253 | 
254 |     AiaMutex( Lock )( &recorder->mutex );
255 |     PaError err = Pa_StartStream( recorder->paStream );
256 |     AiaMutex( Unlock )( &recorder->mutex );
257 |     if( err != paNoError )
258 |     {
259 |         AiaLogError( "Failed to start PortAudio stream" );
260 |         AiaTimer( Destroy )( &recorder->captureMicrophoneTimer );
261 |         recorder->captureMicrophoneTimerExisted = false;
262 |         return false;
263 |     }
264 | 
265 |     if( !AiaTimer( Arm )( &recorder->captureMicrophoneTimer, 0,
266 |                           MICROPHONE_PUBLISH_RATE / 4 ) )
267 |     {
268 |         AiaLogError( "Failed to arm captureMicrophoneTimer" );
269 |         AiaMutex( Lock )( &recorder->mutex );
270 |         Pa_CloseStream( recorder->paStream );
271 |         AiaMutex( Unlock )( &recorder->mutex );
272 |         AiaTimer( Destroy )( &recorder->captureMicrophoneTimer );
273 |         recorder->captureMicrophoneTimerExisted = false;
274 |         return false;
275 |     }
276 | 
277 |     return true;
278 | }
279 | 
280 | bool AiaPortAudioMicrophoneRecorder_StopStreamingMicrophoneData(
281 |     AiaPortAudioMicrophoneRecorder_t* recorder )
282 | {
283 |     AiaAssert( recorder );
284 |     if( !recorder )
285 |     {
286 |         AiaLogError( "Null recorder" );
287 |         return false;
288 |     }
289 | 
290 |     AiaTimer(Destroy)(&recorder->captureMicrophoneTimer);
291 |     recorder->captureMicrophoneTimerExisted = false;
292 | 
293 |     AiaMutex( Lock )( &recorder->mutex );
294 |     PaError err = Pa_StopStream( recorder->paStream );
295 |     AiaMutex( Unlock )( &recorder->mutex );
296 |     if( err != paNoError )
297 |     {
298 |         AiaLogError( "Failed to stop PortAudio stream" );
299 |         return false;
300 |     }
301 |     return true;
302 | }
303 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | 
  2 |                                  Apache License
  3 |                            Version 2.0, January 2004
  4 |                         http://www.apache.org/licenses/
  5 | 
  6 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  7 | 
  8 |    1. Definitions.
  9 | 
 10 |       "License" shall mean the terms and conditions for use, reproduction,
 11 |       and distribution as defined by Sections 1 through 9 of this document.
 12 | 
 13 |       "Licensor" shall mean the copyright owner or entity authorized by
 14 |       the copyright owner that is granting the License.
 15 | 
 16 |       "Legal Entity" shall mean the union of the acting entity and all
 17 |       other entities that control, are controlled by, or are under common
 18 |       control with that entity. For the purposes of this definition,
 19 |       "control" means (i) the power, direct or indirect, to cause the
 20 |       direction or management of such entity, whether by contract or
 21 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 22 |       outstanding shares, or (iii) beneficial ownership of such entity.
 23 | 
 24 |       "You" (or "Your") shall mean an individual or Legal Entity
 25 |       exercising permissions granted by this License.
 26 | 
 27 |       "Source" form shall mean the preferred form for making modifications,
 28 |       including but not limited to software source code, documentation
 29 |       source, and configuration files.
 30 | 
 31 |       "Object" form shall mean any form resulting from mechanical
 32 |       transformation or translation of a Source form, including but
 33 |       not limited to compiled object code, generated documentation,
 34 |       and conversions to other media types.
 35 | 
 36 |       "Work" shall mean the work of authorship, whether in Source or
 37 |       Object form, made available under the License, as indicated by a
 38 |       copyright notice that is included in or attached to the work
 39 |       (an example is provided in the Appendix below).
 40 | 
 41 |       "Derivative Works" shall mean any work, whether in Source or Object
 42 |       form, that is based on (or derived from) the Work and for which the
 43 |       editorial revisions, annotations, elaborations, or other modifications
 44 |       represent, as a whole, an original work of authorship. For the purposes
 45 |       of this License, Derivative Works shall not include works that remain
 46 |       separable from, or merely link (or bind by name) to the interfaces of,
 47 |       the Work and Derivative Works thereof.
 48 | 
 49 |       "Contribution" shall mean any work of authorship, including
 50 |       the original version of the Work and any modifications or additions
 51 |       to that Work or Derivative Works thereof, that is intentionally
 52 |       submitted to Licensor for inclusion in the Work by the copyright owner
 53 |       or by an individual or Legal Entity authorized to submit on behalf of
 54 |       the copyright owner. For the purposes of this definition, "submitted"
 55 |       means any form of electronic, verbal, or written communication sent
 56 |       to the Licensor or its representatives, including but not limited to
 57 |       communication on electronic mailing lists, source code control systems,
 58 |       and issue tracking systems that are managed by, or on behalf of, the
 59 |       Licensor for the purpose of discussing and improving the Work, but
 60 |       excluding communication that is conspicuously marked or otherwise
 61 |       designated in writing by the copyright owner as "Not a Contribution."
 62 | 
 63 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 64 |       on behalf of whom a Contribution has been received by Licensor and
 65 |       subsequently incorporated within the Work.
 66 | 
 67 |    2. Grant of Copyright License. Subject to the terms and conditions of
 68 |       this License, each Contributor hereby grants to You a perpetual,
 69 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 70 |       copyright license to reproduce, prepare Derivative Works of,
 71 |       publicly display, publicly perform, sublicense, and distribute the
 72 |       Work and such Derivative Works in Source or Object form.
 73 | 
 74 |    3. Grant of Patent License. Subject to the terms and conditions of
 75 |       this License, each Contributor hereby grants to You a perpetual,
 76 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 77 |       (except as stated in this section) patent license to make, have made,
 78 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 79 |       where such license applies only to those patent claims licensable
 80 |       by such Contributor that are necessarily infringed by their
 81 |       Contribution(s) alone or by combination of their Contribution(s)
 82 |       with the Work to which such Contribution(s) was submitted. If You
 83 |       institute patent litigation against any entity (including a
 84 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 85 |       or a Contribution incorporated within the Work constitutes direct
 86 |       or contributory patent infringement, then any patent licenses
 87 |       granted to You under this License for that Work shall terminate
 88 |       as of the date such litigation is filed.
 89 | 
 90 |    4. Redistribution. You may reproduce and distribute copies of the
 91 |       Work or Derivative Works thereof in any medium, with or without
 92 |       modifications, and in Source or Object form, provided that You
 93 |       meet the following conditions:
 94 | 
 95 |       (a) You must give any other recipients of the Work or
 96 |           Derivative Works a copy of this License; and
 97 | 
 98 |       (b) You must cause any modified files to carry prominent notices
 99 |           stating that You changed the files; and
100 | 
101 |       (c) You must retain, in the Source form of any Derivative Works
102 |           that You distribute, all copyright, patent, trademark, and
103 |           attribution notices from the Source form of the Work,
104 |           excluding those notices that do not pertain to any part of
105 |           the Derivative Works; and
106 | 
107 |       (d) If the Work includes a "NOTICE" text file as part of its
108 |           distribution, then any Derivative Works that You distribute must
109 |           include a readable copy of the attribution notices contained
110 |           within such NOTICE file, excluding those notices that do not
111 |           pertain to any part of the Derivative Works, in at least one
112 |           of the following places: within a NOTICE text file distributed
113 |           as part of the Derivative Works; within the Source form or
114 |           documentation, if provided along with the Derivative Works; or,
115 |           within a display generated by the Derivative Works, if and
116 |           wherever such third-party notices normally appear. The contents
117 |           of the NOTICE file are for informational purposes only and
118 |           do not modify the License. You may add Your own attribution
119 |           notices within Derivative Works that You distribute, alongside
120 |           or as an addendum to the NOTICE text from the Work, provided
121 |           that such additional attribution notices cannot be construed
122 |           as modifying the License.
123 | 
124 |       You may add Your own copyright statement to Your modifications and
125 |       may provide additional or different license terms and conditions
126 |       for use, reproduction, or distribution of Your modifications, or
127 |       for any such Derivative Works as a whole, provided Your use,
128 |       reproduction, and distribution of the Work otherwise complies with
129 |       the conditions stated in this License.
130 | 
131 |    5. Submission of Contributions. Unless You explicitly state otherwise,
132 |       any Contribution intentionally submitted for inclusion in the Work
133 |       by You to the Licensor shall be under the terms and conditions of
134 |       this License, without any additional terms or conditions.
135 |       Notwithstanding the above, nothing herein shall supersede or modify
136 |       the terms of any separate license agreement you may have executed
137 |       with Licensor regarding such Contributions.
138 | 
139 |    6. Trademarks. This License does not grant permission to use the trade
140 |       names, trademarks, service marks, or product names of the Licensor,
141 |       except as required for reasonable and customary use in describing the
142 |       origin of the Work and reproducing the content of the NOTICE file.
143 | 
144 |    7. Disclaimer of Warranty. Unless required by applicable law or
145 |       agreed to in writing, Licensor provides the Work (and each
146 |       Contributor provides its Contributions) on an "AS IS" BASIS,
147 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
148 |       implied, including, without limitation, any warranties or conditions
149 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
150 |       PARTICULAR PURPOSE. You are solely responsible for determining the
151 |       appropriateness of using or redistributing the Work and assume any
152 |       risks associated with Your exercise of permissions under this License.
153 | 
154 |    8. Limitation of Liability. In no event and under no legal theory,
155 |       whether in tort (including negligence), contract, or otherwise,
156 |       unless required by applicable law (such as deliberate and grossly
157 |       negligent acts) or agreed to in writing, shall any Contributor be
158 |       liable to You for damages, including any direct, indirect, special,
159 |       incidental, or consequential damages of any character arising as a
160 |       result of this License or out of the use or inability to use the
161 |       Work (including but not limited to damages for loss of goodwill,
162 |       work stoppage, computer failure or malfunction, or any and all
163 |       other commercial damages or losses), even if such Contributor
164 |       has been advised of the possibility of such damages.
165 | 
166 |    9. Accepting Warranty or Additional Liability. While redistributing
167 |       the Work or Derivative Works thereof, You may choose to offer,
168 |       and charge a fee for, acceptance of support, warranty, indemnity,
169 |       or other liability obligations and/or rights consistent with this
170 |       License. However, in accepting such obligations, You may act only
171 |       on Your own behalf and on Your sole responsibility, not on behalf
172 |       of any other Contributor, and only if You agree to indemnify,
173 |       defend, and hold each Contributor harmless for any liability
174 |       incurred by, or claims asserted against, such Contributor by reason
175 |       of your accepting any such warranty or additional liability.


--------------------------------------------------------------------------------
/ports/Crypto/include/crypto/aia_crypto_config.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #ifndef AIA_CRYPTO_CONFIG_H_
 18 | #ifdef __cplusplus
 19 | extern "C" {
 20 | #endif
 21 | #define AIA_CRYPTO_CONFIG_H_
 22 | 
 23 | /* AIA headers */
 24 | #include <aiacore/aia_crypto_mbedtls.h>
 25 | #include <aiacore/aia_encryption_algorithm.h>
 26 | #include <aiacore/aia_random_mbedtls.h>
 27 | #include <aiacore/aia_secret_derivation_algorithm.h>
 28 | #include <aiacore/mbedtls/aia_base64_mbedtls.h>
 29 | 
 30 | static const AiaSecretDerivationAlgorithm_t SECRET_DERIVATION_ALGORITHM =
 31 |     AIA_ECDH_CURVE_25519_32_BYTE;
 32 | 
 33 | /**
 34 |  * Seeds the random number generator.
 35 |  * @note Implementations of this function must be thread safe.
 36 |  *
 37 |  * @param salt Changes the starting point for the random generator (may
 38 |  * be NULL and does not need to be '\0' terminated).
 39 |  * @param saltLength The length of @c salt.
 40 |  * @return @c true if random number generator is successfully seeded, else @c
 41 |  * false.
 42 |  */
 43 | static inline bool AiaRandom_Seed( const char* salt, size_t saltLength )
 44 | {
 45 |     return AiaRandomMbedtls_Seed( salt, saltLength );
 46 | }
 47 | 
 48 | /**
 49 |  * Generates a cryptographically secure random number.
 50 |  * @note Implementations of this function must be thread safe.
 51 |  *
 52 |  * @param [out] buffer The buffer to fill with random data
 53 |  * @param bufferLength The length of @c buffer.
 54 |  * @return @c true if random number is generated successfully, else
 55 |  * @c false.
 56 |  */
 57 | static inline bool AiaRandom_Rand( unsigned char* buffer, size_t bufferLength )
 58 | {
 59 |     return AiaRandomMbedtls_Rand( buffer, bufferLength );
 60 | }
 61 | 
 62 | /**
 63 |  * Sets the key for encryption/decryption functions.
 64 |  *
 65 |  * @param encryptKey The encryption key to use.
 66 |  * @param encryptKeySize The size of @c encryptKey (in bytes).
 67 |  * @param encryptAlgorithm The encryption algorithm to use.
 68 |  *
 69 |  * @return @c true if the key is set successfully, else @c false.
 70 |  */
 71 | bool AiaCrypto_SetKey( const uint8_t* encryptKey, size_t encryptKeySize,
 72 |                        const AiaEncryptionAlgorithm_t encryptAlgorithm );
 73 | 
 74 | /**
 75 |  * Encrypts given input data. This function is thread-safe.
 76 |  *
 77 |  * @param inputData The buffer that holds the data to encrypt. Has to be at
 78 |  * least @c inputLen bytes in size.
 79 |  * @param inputLen The size of the buffer that holds the input data in bytes.
 80 |  * Also equal to the size of the @c outputData.
 81 |  * @param [out] outputData The buffer that holds the ciphertext. Has to be at
 82 |  * least @c inputLen bytes in size. For encryption, the outputData buffer can be
 83 |  * the same as the inputData buffer.
 84 |  * @param [out] iv The initialization vector will be generated with a size of
 85 |  * @c ivLen bytes for the user.
 86 |  * @param ivLen The length of the initialization vector.
 87 |  * @param [out] tag The buffer for holding the tag generated during encryption.
 88 |  * Has to be at least @c tagLen bytes in size.
 89 |  * @param tagLen The length of the tag generated during encryption.
 90 |  *
 91 |  * @return @c true if encryption is successful, else @c false.
 92 |  */
 93 | static inline bool AiaCrypto_Encrypt( const uint8_t* inputData,
 94 |                                       const size_t inputLen,
 95 |                                       uint8_t* outputData, uint8_t* iv,
 96 |                                       size_t ivLen, uint8_t* tag,
 97 |                                       const size_t tagLen )
 98 | {
 99 |     return AiaCryptoMbedtls_Encrypt( inputData, inputLen, outputData, iv, ivLen,
100 |                                      tag, tagLen );
101 | }
102 | 
103 | /**
104 |  * Decrypts given encrypted data. This function is thread-safe.
105 |  *
106 |  * @param inputData The buffer holding the ciphertext.
107 |  * @param inputLen The length of the ciphertext to decrypt. Also equal to the
108 |  * length of the decrypted plaintext.
109 |  * @param [out] outputData The buffer that holds the plaintext. Has to be at
110 |  * least @c inputLen bytes in size. For decryption, the outputData buffer cannot
111 |  * be the same as inputData buffer. If the buffers overlap, the outputData
112 |  * buffer must trail at least 8 Bytes behind the inputData buffer.
113 |  * @param iv The initialization vector of at least @c ivLen bytes.
114 |  * @param ivLen The length of the initialization vector.
115 |  * @param tag The buffer for holding the tag to verify. Has to be at least @c
116 |  * tagLen bytes in size.
117 |  * @param tagLen The length of the tag generated during encryption.
118 |  *
119 |  * @return @c true if decryption is successful, else @c false.
120 |  */
121 | static inline bool AiaCrypto_Decrypt( const uint8_t* inputData,
122 |                                       const size_t inputLen,
123 |                                       uint8_t* outputData, const uint8_t* iv,
124 |                                       const size_t ivLen, const uint8_t* tag,
125 |                                       const size_t tagLen )
126 | {
127 |     return AiaCryptoMbedtls_Decrypt( inputData, inputLen, outputData, iv, ivLen,
128 |                                      tag, tagLen );
129 | }
130 | 
131 | /**
132 |  * Generates a key pair intended for the specified shared secret calculation.
133 |  *
134 |  * @param secretDerivationAlgorithm The secret derivation algorithm to generate
135 |  * a key pair for.
136 |  * @param[out] privateKey The buffer to write binary private key data into.
137 |  * @param privateKeyLen The length of @c privateKey.
138 |  * @param[out] publicKey The buffer to write binary public key data into.
139 |  * @param publicKeyLen The length of @c publicKey.
140 |  * @return @c true if key pair generated successfully, else @c false.
141 |  */
142 | static inline bool AiaCrypto_GenerateKeyPair(
143 |     AiaSecretDerivationAlgorithm_t secretDerivationAlgorithm,
144 |     uint8_t* privateKey, size_t privateKeyLen, uint8_t* publicKey,
145 |     size_t publicKeyLen )
146 | {
147 |     return AiaCryptoMbedtls_GenerateKeyPair( secretDerivationAlgorithm,
148 |                                              privateKey, privateKeyLen,
149 |                                              publicKey, publicKeyLen );
150 | }
151 | 
152 | /**
153 |  * Calculates the shared secret between client and service
154 |  *
155 |  * @param clientPrivateKey The buffer holding binary client private key data.
156 |  * @param clientPrivateKeyLen The length of @c clientPrivateKey.
157 |  * @param servicePublicKey The buffer holding binary service public key data.
158 |  * @param servicePublicKeyLen The length of @c servicePublicKey.
159 |  * @param secretDerivationAlgorithm The secret derivation algorithm to use.
160 |  * @param[out] sharedSecret The buffer to write binary shared secret data into.
161 |  * @param sharedSecretLen The length of @c sharedSecret
162 |  * @return @c true if shared secret is calculated successfully, else @c false.
163 |  */
164 | static inline bool AiaCrypto_CalculateSharedSecret(
165 |     const uint8_t* clientPrivateKey, size_t clientPrivateKeyLen,
166 |     const uint8_t* servicePublicKey, size_t servicePublicKeyLen,
167 |     AiaSecretDerivationAlgorithm_t secretDerivationAlgorithm,
168 |     uint8_t* sharedSecret, size_t sharedSecretLen )
169 | {
170 |     return AiaCryptoMbedtls_CalculateSharedSecret(
171 |         clientPrivateKey, clientPrivateKeyLen, servicePublicKey,
172 |         servicePublicKeyLen, secretDerivationAlgorithm, sharedSecret,
173 |         sharedSecretLen );
174 | }
175 | 
176 | /**
177 |  * Returns the size required for an output buffer for encoding to base64.
178 |  *
179 |  * @param input The buffer to encode/decode.
180 |  * @param inputLen The length of @c input.
181 |  * @return The required buffer size for encoding to or decoding from base64. @c
182 |  * 0 will be returned on failures.
183 |  */
184 | static inline size_t Aia_Base64GetEncodeSize( const uint8_t* input,
185 |                                               size_t inputLen )
186 | {
187 |     return AiaBase64MbedTls_GetEncodeSize( input, inputLen );
188 | }
189 | 
190 | /**
191 |  * Returns the size required for an output buffer for decoding from base64.
192 |  *
193 |  * @param input The buffer to encode/decode.
194 |  * @param inputLen The length of @c input.
195 |  * @return The required buffer size for encoding to or decoding from base64. @c
196 |  * 0 will be returned on failures.
197 |  */
198 | static inline size_t Aia_Base64GetDecodeSize( const uint8_t* input,
199 |                                               size_t inputLen )
200 | {
201 |     return AiaBase64MbedTls_GetDecodeSize( input, inputLen );
202 | }
203 | 
204 | /**
205 |  * Encodes the provided buffer using base64 encoding.
206 |  *
207 |  * @param input The buffer to encode.
208 |  * @param inputLen The length of @c input.
209 |  * @param[out] output The output buffer to write encoded bytes into. This cannot
210 |  * be the same as @c input.
211 |  * @param outputLen The length of @c output.
212 |  * @return @c true if successful or @c false otherwise.
213 |  * @note Users should use @c Aia_Base64GetEncodeSize to obtain the required size
214 |  * of @c output.
215 |  */
216 | static inline bool Aia_Base64Encode( const uint8_t* input, size_t inputLen,
217 |                                      uint8_t* output, size_t outputLen )
218 | {
219 |     return AiaBase64MbedTls_Encode( input, inputLen, output, outputLen );
220 | }
221 | 
222 | /**
223 |  * Decodes a base64 encoded buffer.
224 |  *
225 |  * @param input The base64 encoded buffer to decode.
226 |  * @param inputLen The length of @c input.
227 |  * @param[out] output The output buffer to write decoded bytes into. This cannot
228 |  * be the same as @c input.
229 |  * @param outputLen The length of @c output.
230 |  * @return @c true if successful or @c false otherwise.
231 |  * @note Users should use @c Aia_Base64GetDecodeSize to obtain the required size
232 |  * of @c output.
233 |  */
234 | static inline bool Aia_Base64Decode( const uint8_t* input, size_t inputLen,
235 |                                      uint8_t* output, size_t outputLen )
236 | {
237 |     return AiaBase64MbedTls_Decode( input, inputLen, output, outputLen );
238 | }
239 | 
240 | #ifdef __cplusplus
241 | }
242 | #endif
243 | #endif /* ifndef AIA_CRYPTO_CONFIG_H_ */
244 | 


--------------------------------------------------------------------------------
/ports/HTTP/src/aia_http_config.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_http_config.c
 19 |  * @brief Implements platform-specific Crypto functions which are not inlined in
 20 |  * @c aia_http_config.h.
 21 |  */
 22 | 
 23 | #include <aia_config.h>
 24 | #include <http/aia_http_config.h>
 25 | #include "iot_https_client.h"
 26 | #include "iot_https_utils.h"
 27 | 
 28 | #ifndef AIA_AFR_HTTPS_TRUSTED_ROOT_CA
 29 | #define AIA_AFR_HTTPS_TRUSTED_ROOT_CA                                    \
 30 |     "-----BEGIN CERTIFICATE-----\n"                                      \
 31 |     "MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\n" \
 32 |     "ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\n" \
 33 |     "b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL\n" \
 34 |     "MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\n" \
 35 |     "b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj\n" \
 36 |     "ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM\n" \
 37 |     "9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw\n" \
 38 |     "IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6\n" \
 39 |     "VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L\n" \
 40 |     "93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm\n" \
 41 |     "jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\n" \
 42 |     "AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA\n" \
 43 |     "A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI\n" \
 44 |     "U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs\n" \
 45 |     "N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv\n" \
 46 |     "o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU\n" \
 47 |     "5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy\n" \
 48 |     "rqXRfboQnoZsG4q5WTP468SQvvG5\n"                                     \
 49 |     "-----END CERTIFICATE-----\n"
 50 | #endif /* ifndef AIA_AFR_HTTPS_TRUSTED_ROOT_CA */
 51 | 
 52 | #define AIA_AFR_HTTPS_BUFFER_SIZE ( (int)384 )
 53 | static const IotNetworkInterface_t* _pAiaNetIf;
 54 | static const void* _pAiaNetCredentialInfo;
 55 | static char* _reqHeader = "Content-Type";
 56 | static char* _reqHeaderVal = "application/json";
 57 | 
 58 | bool AiaHttpStoreNetworkInfo( const IotNetworkInterface_t* pNetworkInterface,
 59 |                               const void* pNetworkCredentialInfo )
 60 | {
 61 |     if( pNetworkInterface && pNetworkCredentialInfo )
 62 |     {
 63 |         _pAiaNetIf = pNetworkInterface;
 64 |         _pAiaNetCredentialInfo = pNetworkCredentialInfo;
 65 |         return true;
 66 |     }
 67 |     else
 68 |     {
 69 |         return false;
 70 |     }
 71 | }
 72 | 
 73 | bool AiaSendHttpsRequest( AiaHttpsRequest_t* httpsRequest,
 74 |                           AiaHttpsConnectionResponseCallback_t responseCallback,
 75 |                           void* responseCallbackUserData,
 76 |                           AiaHttpsConnectionFailureCallback_t failureCallback,
 77 |                           void* failureCallbackUserData )
 78 | {
 79 |     IotHttpsReturnCode_t httpsClientStatus = IOT_HTTPS_OK;
 80 |     IotHttpsConnectionInfo_t connConfig = { 0 };
 81 |     IotHttpsRequestInfo_t reqConfig = { 0 };
 82 |     IotHttpsResponseInfo_t respConfig = { 0 };
 83 |     IotHttpsConnectionHandle_t connHandle =
 84 |         IOT_HTTPS_CONNECTION_HANDLE_INITIALIZER;
 85 |     IotHttpsRequestHandle_t reqHandle = IOT_HTTPS_REQUEST_HANDLE_INITIALIZER;
 86 |     IotHttpsResponseHandle_t respHandle = IOT_HTTPS_RESPONSE_HANDLE_INITIALIZER;
 87 |     IotHttpsSyncInfo_t reqSyncInfo = { 0 };
 88 |     IotHttpsSyncInfo_t respSyncInfo = { 0 };
 89 |     const char* pPath = NULL;
 90 |     size_t pathLen = 0;
 91 |     const char* pAddress = NULL;
 92 |     size_t addressLen = 0;
 93 |     uint16_t respStatus = IOT_HTTPS_STATUS_OK;
 94 |     uint32_t retryNum = 0;
 95 |     size_t rspBodyLen = 0;
 96 |     uint8_t _pConnUserBuffer[ AIA_AFR_HTTPS_BUFFER_SIZE ] = { 0 };
 97 |     uint8_t _pReqUserBuffer[ AIA_AFR_HTTPS_BUFFER_SIZE ] = { 0 };
 98 |     uint8_t _pRespUserBuffer[ AIA_AFR_HTTPS_BUFFER_SIZE ] = { 0 };
 99 |     uint8_t _pRespBodyBuffer[ AIA_AFR_HTTPS_BUFFER_SIZE ] = { 0 };
100 | 
101 |     httpsClientStatus = IotHttpsClient_GetUrlPath(
102 |         httpsRequest->url, strlen( httpsRequest->url ), &pPath, &pathLen );
103 |     if( httpsClientStatus != IOT_HTTPS_OK )
104 |     {
105 |         AiaLogError(
106 |             "An error occurred in IotHttpsClient_GetUrlPath() on URL %s. Error "
107 |             "code: %d",
108 |             httpsRequest->url, httpsClientStatus );
109 |         return false;
110 |     }
111 |     httpsClientStatus = IotHttpsClient_GetUrlAddress(
112 |         httpsRequest->url, strlen( httpsRequest->url ), &pAddress,
113 |         &addressLen );
114 |     if( httpsClientStatus != IOT_HTTPS_OK )
115 |     {
116 |         AiaLogError(
117 |             "An error occurred in IotHttpsClient_GetUrlAddress() on URL "
118 |             "%s\r\n. Error code %d",
119 |             httpsRequest->url, httpsClientStatus );
120 |         return false;
121 |     }
122 |     if( httpsRequest->method != AIA_HTTPS_METHOD_POST )
123 |     {
124 |         AiaLogError( "Unsupported AiaHttpsMethod_t, method=%d",
125 |                      httpsRequest->method );
126 |         return false;
127 |     }
128 |     httpsClientStatus = IotHttpsClient_Init();
129 |     if( httpsClientStatus != IOT_HTTPS_OK )
130 |     {
131 |         AiaLogError(
132 |             "An error occurred initializing the HTTPS library. Error code: %d",
133 |             httpsClientStatus );
134 |         return false;
135 |     }
136 | 
137 |     connConfig.pAddress = pAddress;
138 |     connConfig.addressLen = addressLen;
139 |     connConfig.port = 443;
140 |     connConfig.pCaCert = AIA_AFR_HTTPS_TRUSTED_ROOT_CA;
141 |     connConfig.caCertLen = sizeof( AIA_AFR_HTTPS_TRUSTED_ROOT_CA );
142 |     connConfig.userBuffer.pBuffer = _pConnUserBuffer;
143 |     connConfig.userBuffer.bufferLen = sizeof( _pConnUserBuffer );
144 |     connConfig.pClientCert =
145 |         ( (IotNetworkCredentials_t*)_pAiaNetCredentialInfo )->pClientCert;
146 |     connConfig.clientCertLen =
147 |         ( (IotNetworkCredentials_t*)_pAiaNetCredentialInfo )->clientCertSize;
148 |     connConfig.pPrivateKey =
149 |         ( (IotNetworkCredentials_t*)_pAiaNetCredentialInfo )->pPrivateKey;
150 |     connConfig.privateKeyLen =
151 |         ( (IotNetworkCredentials_t*)_pAiaNetCredentialInfo )->privateKeySize;
152 |     connConfig.pNetworkInterface = _pAiaNetIf;
153 | 
154 |     reqSyncInfo.pBody = (uint8_t*)( httpsRequest->body );
155 |     reqSyncInfo.bodyLen = strlen( httpsRequest->body );
156 |     respSyncInfo.pBody = (uint8_t*)_pRespBodyBuffer;
157 |     respSyncInfo.bodyLen = sizeof( _pRespBodyBuffer );
158 | 
159 |     reqConfig.pPath = pPath;
160 |     reqConfig.pathLen = strlen( pPath );
161 |     reqConfig.pHost = pAddress;
162 |     reqConfig.hostLen = addressLen;
163 |     reqConfig.method = IOT_HTTPS_METHOD_POST;
164 |     reqConfig.isNonPersistent = false;
165 |     reqConfig.userBuffer.pBuffer = _pReqUserBuffer;
166 |     reqConfig.userBuffer.bufferLen = sizeof( _pReqUserBuffer );
167 |     reqConfig.isAsync = false;
168 |     reqConfig.u.pSyncInfo = &reqSyncInfo;
169 | 
170 |     respConfig.userBuffer.pBuffer = _pRespUserBuffer;
171 |     respConfig.userBuffer.bufferLen = sizeof( _pRespUserBuffer );
172 |     respConfig.pSyncInfo = &respSyncInfo;
173 | 
174 |     httpsClientStatus =
175 |         IotHttpsClient_InitializeRequest( &reqHandle, &reqConfig );
176 |     if( httpsClientStatus != IOT_HTTPS_OK )
177 |     {
178 |         AiaLogError(
179 |             "An error occurred in IotHttpsClient_InitializeRequest() with "
180 |             "error code: %d",
181 |             httpsClientStatus );
182 |         IotHttpsClient_Cleanup();
183 |         return false;
184 |     }
185 | 
186 |     httpsClientStatus = IotHttpsClient_Connect( &connHandle, &connConfig );
187 |     if( httpsClientStatus != IOT_HTTPS_OK )
188 |     {
189 |         AiaLogError( "Failed to connect to the server. Error code: %d.",
190 |                      httpsClientStatus );
191 |         IotHttpsClient_Cleanup();
192 |         return false;
193 |     }
194 | 
195 |     httpsClientStatus =
196 |         IotHttpsClient_AddHeader( reqHandle, _reqHeader, strlen( _reqHeader ),
197 |                                   _reqHeaderVal, strlen( _reqHeaderVal ) );
198 |     if( httpsClientStatus == IOT_HTTPS_NETWORK_ERROR )
199 |     {
200 |         AiaLogError( "Failed to add header. Error code: %d.",
201 |                      httpsClientStatus );
202 |         IotHttpsClient_Disconnect( connHandle );
203 |         IotHttpsClient_Cleanup();
204 |         return false;
205 |     }
206 | 
207 |     httpsClientStatus = IotHttpsClient_SendSync( connHandle, reqHandle,
208 |                                                  &respHandle, &respConfig, 0 );
209 |     if( httpsClientStatus != IOT_HTTPS_NETWORK_ERROR )
210 |     {
211 |         httpsClientStatus =
212 |             IotHttpsClient_ReadResponseStatus( respHandle, &respStatus );
213 |         if( httpsClientStatus != IOT_HTTPS_OK )
214 |         {
215 |             AiaLogError(
216 |                 "Error in retreiving the response status. Error code %d",
217 |                 httpsClientStatus );
218 |             failureCallback( failureCallbackUserData );
219 |         }
220 |         else if( respStatus != IOT_HTTPS_STATUS_OK )
221 |         {
222 |             AiaLogError( "Failed to register to AIS. Response status: %d",
223 |                          respStatus );
224 |             failureCallback( failureCallbackUserData );
225 |         }
226 |         else
227 |         {
228 |             AiaHttpsResponse_t response;
229 |             httpsClientStatus =
230 |                 IotHttpsClient_ReadContentLength( respHandle, &rspBodyLen );
231 | 
232 |             if( httpsClientStatus == IOT_HTTPS_OK )
233 |             {
234 |                 response.body = _pRespBodyBuffer;
235 |                 response.bodyLen = rspBodyLen;
236 |                 response.status = respStatus;
237 |                 responseCallback( &response, responseCallbackUserData );
238 |                 AiaLogInfo( "AIS registration success." );
239 |             }
240 |             else
241 |             {
242 |                 AiaLogError(
243 |                     "Failed to read the Content-Length from the response. "
244 |                     "Error code %d",
245 |                     httpsClientStatus );
246 |             }
247 |         }
248 |     }
249 |     else
250 |     {
251 |         AiaLogError( "Failed to SendSync to the server. Error code: %d.",
252 |                      httpsClientStatus );
253 |     }
254 | 
255 |     if( connHandle != NULL )
256 |     {
257 |         IotHttpsClient_Disconnect( connHandle );
258 |     }
259 | 
260 |     IotHttpsClient_Cleanup();
261 | 
262 |     return true;
263 | }
264 | 


--------------------------------------------------------------------------------
/demos/aia/aia_sample_main.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2019-2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
  3 |  *
  4 |  * You may not use this file except in compliance with the terms and conditions
  5 |  * set forth in the accompanying LICENSE file.
  6 |  *
  7 |  * THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
  8 |  * DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
  9 |  * IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 10 |  * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
 11 |  */
 12 | 
 13 | /* The config header is always included first. */
 14 | #include "iot_config.h"
 15 | 
 16 | /* Standard includes. */
 17 | #include <stdbool.h>
 18 | #include <stdio.h>
 19 | #include <stdlib.h>
 20 | #include <string.h>
 21 | 
 22 | /* Set up logging for this demo. */
 23 | #include "iot_demo_logging.h"
 24 | 
 25 | /* Platform layer includes. */
 26 | #include "platform/iot_clock.h"
 27 | #include "platform/iot_threads.h"
 28 | 
 29 | /* AIA include. */
 30 | #include "aia_sample_app.h"
 31 | 
 32 | /**
 33 |  * @cond DOXYGEN_IGNORE
 34 |  * Doxygen should ignore this section.
 35 |  *
 36 |  * Provide default values for undefined configuration settings.
 37 |  */
 38 | #ifndef IOT_DEMO_MQTT_TOPIC_PREFIX
 39 |     #define IOT_DEMO_MQTT_TOPIC_PREFIX           "iotdemo"
 40 | #endif
 41 | #ifndef IOT_DEMO_MQTT_PUBLISH_BURST_SIZE
 42 |     #define IOT_DEMO_MQTT_PUBLISH_BURST_SIZE     ( 10 )
 43 | #endif
 44 | #ifndef IOT_DEMO_MQTT_PUBLISH_BURST_COUNT
 45 |     #define IOT_DEMO_MQTT_PUBLISH_BURST_COUNT    ( 10 )
 46 | #endif
 47 | /** @endcond */
 48 | 
 49 | /**
 50 |  * @brief The first characters in the client identifier. A timestamp is appended
 51 |  * to this prefix to create a unique client identifer.
 52 |  *
 53 |  * This prefix is also used to generate topic names and topic filters used in this
 54 |  * demo.
 55 |  */
 56 | #define CLIENT_IDENTIFIER_PREFIX                 "iotdemo"
 57 | 
 58 | /**
 59 |  * @brief The longest client identifier that an MQTT server must accept (as defined
 60 |  * by the MQTT 3.1.1 spec) is 23 characters. Add 1 to include the length of the NULL
 61 |  * terminator.
 62 |  */
 63 | #define CLIENT_IDENTIFIER_MAX_LENGTH             ( 24 )
 64 | 
 65 | /**
 66 |  * @brief The keep-alive interval used for this demo.
 67 |  *
 68 |  * An MQTT ping request will be sent periodically at this interval.
 69 |  */
 70 | #define KEEP_ALIVE_SECONDS                       ( 60 )
 71 | 
 72 | /**
 73 |  * @brief The Last Will and Testament topic name in this demo.
 74 |  *
 75 |  * The MQTT server will publish a message to this topic name if this client is
 76 |  * unexpectedly disconnected.
 77 |  */
 78 | #define WILL_TOPIC_NAME                          IOT_DEMO_MQTT_TOPIC_PREFIX "/will"
 79 | 
 80 | /**
 81 |  * @brief The length of #WILL_TOPIC_NAME.
 82 |  */
 83 | #define WILL_TOPIC_NAME_LENGTH                   ( ( uint16_t ) ( sizeof( WILL_TOPIC_NAME ) - 1 ) )
 84 | 
 85 | /**
 86 |  * @brief The message to publish to #WILL_TOPIC_NAME.
 87 |  */
 88 | #define WILL_MESSAGE                             "MQTT demo unexpectedly disconnected."
 89 | 
 90 | /**
 91 |  * @brief The length of #WILL_MESSAGE.
 92 |  */
 93 | #define WILL_MESSAGE_LENGTH                      ( ( size_t ) ( sizeof( WILL_MESSAGE ) - 1 ) )
 94 | 
 95 | /*-----------------------------------------------------------*/
 96 | 
 97 | /* Declaration of demo function. */
 98 | int RunAiaDemo( bool awsIotMqttMode,
 99 |                  const char * pIdentifier,
100 |                  void * pNetworkServerInfo,
101 |                  void * pNetworkCredentialInfo,
102 |                  const IotNetworkInterface_t * pNetworkInterface );
103 | 
104 | /*-----------------------------------------------------------*/
105 | 
106 | /**
107 |  * @brief Initialize the MQTT library.
108 |  *
109 |  * @return `EXIT_SUCCESS` if all libraries were successfully initialized;
110 |  * `EXIT_FAILURE` otherwise.
111 |  */
112 | static int _initializeDemo( void )
113 | {
114 |     int status = EXIT_SUCCESS;
115 |     IotMqttError_t mqttInitStatus = IOT_MQTT_SUCCESS;
116 | 
117 |     mqttInitStatus = IotMqtt_Init();
118 | 
119 |     if( mqttInitStatus != IOT_MQTT_SUCCESS )
120 |     {
121 |         /* Failed to initialize MQTT library. */
122 |         status = EXIT_FAILURE;
123 |     }
124 | 
125 |     return status;
126 | }
127 | 
128 | /*-----------------------------------------------------------*/
129 | 
130 | /**
131 |  * @brief Clean up the MQTT library.
132 |  */
133 | static void _cleanupDemo( void )
134 | {
135 |     IotMqtt_Cleanup();
136 | }
137 | 
138 | /*-----------------------------------------------------------*/
139 | 
140 | /**
141 |  * @brief Establish a new connection to the MQTT server.
142 |  *
143 |  * @param[in] awsIotMqttMode Specify if this demo is running with the AWS IoT
144 |  * MQTT server. Set this to `false` if using another MQTT server.
145 |  * @param[in] pIdentifier NULL-terminated MQTT client identifier.
146 |  * @param[in] pNetworkServerInfo Passed to the MQTT connect function when
147 |  * establishing the MQTT connection.
148 |  * @param[in] pNetworkCredentialInfo Passed to the MQTT connect function when
149 |  * establishing the MQTT connection.
150 |  * @param[in] pNetworkInterface The network interface to use for this demo.
151 |  * @param[out] pMqttConnection Set to the handle to the new MQTT connection.
152 |  *
153 |  * @return `EXIT_SUCCESS` if the connection is successfully established; `EXIT_FAILURE`
154 |  * otherwise.
155 |  */
156 | static int _establishMqttConnection( bool awsIotMqttMode,
157 |                                      const char * pIdentifier,
158 |                                      void * pNetworkServerInfo,
159 |                                      void * pNetworkCredentialInfo,
160 |                                      const IotNetworkInterface_t * pNetworkInterface,
161 |                                      IotMqttConnection_t * pMqttConnection )
162 | {
163 |     int status = EXIT_SUCCESS;
164 |     IotMqttError_t connectStatus = IOT_MQTT_STATUS_PENDING;
165 |     IotMqttNetworkInfo_t networkInfo = IOT_MQTT_NETWORK_INFO_INITIALIZER;
166 |     IotMqttConnectInfo_t connectInfo = IOT_MQTT_CONNECT_INFO_INITIALIZER;
167 |     IotMqttPublishInfo_t willInfo = IOT_MQTT_PUBLISH_INFO_INITIALIZER;
168 |     char pClientIdentifierBuffer[ CLIENT_IDENTIFIER_MAX_LENGTH ] = { 0 };
169 | 
170 |     /* Set the members of the network info not set by the initializer. This
171 |      * struct provided information on the transport layer to the MQTT connection. */
172 |     networkInfo.createNetworkConnection = true;
173 |     networkInfo.u.setup.pNetworkServerInfo = pNetworkServerInfo;
174 |     networkInfo.u.setup.pNetworkCredentialInfo = pNetworkCredentialInfo;
175 |     networkInfo.pNetworkInterface = pNetworkInterface;
176 | 
177 |     #if ( IOT_MQTT_ENABLE_SERIALIZER_OVERRIDES == 1 ) && defined( IOT_DEMO_MQTT_SERIALIZER )
178 |         networkInfo.pMqttSerializer = IOT_DEMO_MQTT_SERIALIZER;
179 |     #endif
180 | 
181 |     /* Set the members of the connection info not set by the initializer. */
182 |     connectInfo.awsIotMqttMode = awsIotMqttMode;
183 |     connectInfo.cleanSession = true;
184 |     connectInfo.keepAliveSeconds = KEEP_ALIVE_SECONDS;
185 |     connectInfo.pWillInfo = &willInfo;
186 | 
187 |     /* Set the members of the Last Will and Testament (LWT) message info. The
188 |      * MQTT server will publish the LWT message if this client disconnects
189 |      * unexpectedly. */
190 |     willInfo.pTopicName = WILL_TOPIC_NAME;
191 |     willInfo.topicNameLength = WILL_TOPIC_NAME_LENGTH;
192 |     willInfo.pPayload = WILL_MESSAGE;
193 |     willInfo.payloadLength = WILL_MESSAGE_LENGTH;
194 | 
195 |     /* Use the parameter client identifier if provided. Otherwise, generate a
196 |      * unique client identifier. */
197 |     if( ( pIdentifier != NULL ) && ( pIdentifier[ 0 ] != '\0' ) )
198 |     {
199 |         connectInfo.pClientIdentifier = pIdentifier;
200 |         connectInfo.clientIdentifierLength = ( uint16_t ) strlen( pIdentifier );
201 |     }
202 |     else
203 |     {
204 |         /* Every active MQTT connection must have a unique client identifier. The demos
205 |          * generate this unique client identifier by appending a timestamp to a common
206 |          * prefix. */
207 |         status = snprintf( pClientIdentifierBuffer,
208 |                            CLIENT_IDENTIFIER_MAX_LENGTH,
209 |                            CLIENT_IDENTIFIER_PREFIX "%lu",
210 |                            ( long unsigned int ) IotClock_GetTimeMs() );
211 | 
212 |         /* Check for errors from snprintf. */
213 |         if( status < 0 )
214 |         {
215 |             IotLogError( "Failed to generate unique client identifier for demo." );
216 |             status = EXIT_FAILURE;
217 |         }
218 |         else
219 |         {
220 |             /* Set the client identifier buffer and length. */
221 |             connectInfo.pClientIdentifier = pClientIdentifierBuffer;
222 |             connectInfo.clientIdentifierLength = ( uint16_t ) status;
223 | 
224 |             status = EXIT_SUCCESS;
225 |         }
226 |     }
227 | 
228 |     /* Establish the MQTT connection. */
229 |     if( status == EXIT_SUCCESS )
230 |     {
231 |         IotLogInfo( "MQTT demo client identifier is %.*s (length %hu).",
232 |                     connectInfo.clientIdentifierLength,
233 |                     connectInfo.pClientIdentifier,
234 |                     connectInfo.clientIdentifierLength );
235 | 
236 |         connectStatus = IotMqtt_Connect( &networkInfo,
237 |                                          &connectInfo,
238 |                                          MQTT_TIMEOUT_MS,
239 |                                          pMqttConnection );
240 | 
241 |         if( connectStatus != IOT_MQTT_SUCCESS )
242 |         {
243 |             IotLogError( "MQTT CONNECT returned error %s.",
244 |                          IotMqtt_strerror( connectStatus ) );
245 | 
246 |             status = EXIT_FAILURE;
247 |         }
248 |     }
249 | 
250 |     return status;
251 | }
252 | 
253 | /*-----------------------------------------------------------*/
254 | 
255 | /**
256 |  * @brief The function that runs the MQTT demo, called by the demo runner.
257 |  *
258 |  * @param[in] awsIotMqttMode Specify if this demo is running with the AWS IoT
259 |  * MQTT server. Set this to `false` if using another MQTT server.
260 |  * @param[in] pIdentifier NULL-terminated MQTT client identifier.
261 |  * @param[in] pNetworkServerInfo Passed to the MQTT connect function when
262 |  * establishing the MQTT connection.
263 |  * @param[in] pNetworkCredentialInfo Passed to the MQTT connect function when
264 |  * establishing the MQTT connection.
265 |  * @param[in] pNetworkInterface The network interface to use for this demo.
266 |  *
267 |  * @return `EXIT_SUCCESS` if the demo completes successfully; `EXIT_FAILURE` otherwise.
268 |  */
269 | int RunAiaDemo( bool awsIotMqttMode,
270 |                  const char * pIdentifier,
271 |                  void * pNetworkServerInfo,
272 |                  void * pNetworkCredentialInfo,
273 |                  const IotNetworkInterface_t * pNetworkInterface )
274 | {
275 |     /* Return value of this function and the exit status of this program. */
276 |     int status = EXIT_SUCCESS;
277 | 
278 |     /* Handle of the MQTT connection used in this demo. */
279 |     IotMqttConnection_t mqttConnection = IOT_MQTT_CONNECTION_INITIALIZER;
280 | 
281 |     /* Flags for tracking which cleanup functions must be called. */
282 |     bool librariesInitialized = false, connectionEstablished = false;
283 | 
284 |     /* Initialize the libraries required for this demo. */
285 |     status = _initializeDemo();
286 | 
287 |     if( status == EXIT_SUCCESS )
288 |     {
289 |         /* Mark the libraries as initialized. */
290 |         librariesInitialized = true;
291 | 
292 |         /* Establish a new MQTT connection. */
293 |         while (EXIT_SUCCESS != (status = _establishMqttConnection( awsIotMqttMode,
294 |                                            pIdentifier,
295 |                                            pNetworkServerInfo,
296 |                                            pNetworkCredentialInfo,
297 |                                            pNetworkInterface,
298 |                                            &mqttConnection )) ) {}
299 |     }
300 | 
301 |     if( status == EXIT_SUCCESS )
302 |     {
303 |         /* Mark the MQTT connection as established. */
304 |         connectionEstablished = true;
305 | 
306 |         /* Run the AIA Sample Application. */
307 |         AiaSampleApp_t* sampleApp = AiaSampleApp_Create( mqttConnection, clientcredentialIOT_THING_NAME );
308 |         if( !sampleApp )
309 |         {
310 |             AiaLogError( "AiaSampleApp_Create failed" );
311 |             return EXIT_FAILURE;
312 |         }
313 | 
314 |         AiaHttpStoreNetworkInfo( pNetworkInterface, pNetworkCredentialInfo );
315 | 
316 |         AiaSampleApp_Run( sampleApp );
317 |         AiaSampleApp_Destroy( sampleApp );
318 |     }
319 | 
320 |     /* Disconnect the MQTT connection if it was established. */
321 |     if( connectionEstablished == true )
322 |     {
323 |         IotMqtt_Disconnect( mqttConnection, 0 );
324 |     }
325 | 
326 |     /* Clean up libraries if they were initialized. */
327 |     if( librariesInitialized == true )
328 |     {
329 |         _cleanupDemo();
330 |     }
331 | 
332 |     return status;
333 | }
334 | 
335 | /*-----------------------------------------------------------*/
336 | 


--------------------------------------------------------------------------------
/ports/Storage/src/aia_storage_config.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | /**
 18 |  * @file aia_storage_config.c
 19 |  * @brief Implements platform-specific Storage functions which are not inlined
 20 |  * in
 21 |  * @c aia_storage_config.h.
 22 |  */
 23 | 
 24 | #include <storage/aia_storage_config.h>
 25 | 
 26 | #include <aia_config.h>
 27 | 
 28 | #include <aiaalertmanager/aia_alert_constants.h>
 29 | #include <aiacore/aia_volume_constants.h>
 30 | 
 31 | #include <errno.h>
 32 | #include <stdio.h>
 33 | 
 34 | const char* g_aiaClientId;
 35 | const char* g_aiaAwsAccountId;
 36 | const char* g_aiaStorageFolder;
 37 | 
 38 | #ifdef AIA_LOAD_VOLUME
 39 | 
 40 | uint8_t AiaLoadVolume()
 41 | {
 42 |     /* TODO: ADSER-1741 Provide an actual reference implementation of persisting
 43 |      * device volume. */
 44 |     return AIA_DEFAULT_VOLUME;
 45 | }
 46 | 
 47 | #endif
 48 | 
 49 | #define AIA_SHARED_SECRET_STORAGE_KEY "AiaSharedSecretStorageKey"
 50 | #define AIA_ALL_ALERTS_STORAGE_KEY_V0 "AiaAllAlertsStorageKey"
 51 | 
 52 | bool AiaStoreSecret( const uint8_t* sharedSecret, size_t size )
 53 | {
 54 |     return AiaStoreBlob( AIA_SHARED_SECRET_STORAGE_KEY, sharedSecret, size );
 55 | }
 56 | 
 57 | bool AiaLoadSecret( uint8_t* sharedSecret, size_t size )
 58 | {
 59 |     return AiaLoadBlob( AIA_SHARED_SECRET_STORAGE_KEY, sharedSecret, size );
 60 | }
 61 | 
 62 | /** If using the provided sample storage implementation, this is the memory
 63 |  * spaces that the SDK will read/write from/to. 
 64 |  * Vendors should store/load blob to/from NVRAM/persistant storage by their platform
 65 |  */
 66 | 
 67 | /**
 68 |  * blob storage key
 69 |  */
 70 | typedef enum _blobstorage_key_e
 71 | {
 72 |     AIA_BLOB_STORAGE_KEY_START = 0,
 73 |     AIA_BLOB_SHARED_SECRET_STORAGE_KEY = AIA_BLOB_STORAGE_KEY_START,
 74 |     AIA_BLOB_ALL_ALERTS_STORAGE_KEY_V0,
 75 |     AIA_BLOB_TOPIC_ROOT_KEY,
 76 |     AIA_BLOB_STORAGE_KEY_MAX,
 77 | } blobstorage_key_e;
 78 | 
 79 | #define BLOBSTORAGE_SHAREDKEY_SIZE 32
 80 | #define BLOBSTORAGE_ALERTKEY_SIZE 64
 81 | #define BLOBSTORAGE_TOPICROOT_SIZE 16
 82 | 
 83 | typedef struct _blobstorage_t {
 84 |     const char* key;
 85 |     void* const storage;
 86 |     const size_t capacity;
 87 |     size_t used_len;
 88 | } blobstorage_t;
 89 | 
 90 | uint8_t blobstorage_sharedkey[ BLOBSTORAGE_SHAREDKEY_SIZE ];
 91 | uint8_t blobstorage_alertkey[ BLOBSTORAGE_ALERTKEY_SIZE ];
 92 | uint8_t blobstorage_topicroot[ BLOBSTORAGE_TOPICROOT_SIZE ];
 93 | blobstorage_t blobstorage[] = {
 94 |     { AIA_SHARED_SECRET_STORAGE_KEY, blobstorage_sharedkey, sizeof(blobstorage_sharedkey), 0 }, // AIA_BLOB_SHARED_SECRET_STORAGE_KEY
 95 |     { AIA_ALL_ALERTS_STORAGE_KEY_V0, blobstorage_alertkey, sizeof(blobstorage_alertkey), 1 },   // AIA_BLOB_ALL_ALERTS_STORAGE_KEY_V0
 96 |     { "AiaTopicRootKey", blobstorage_topicroot, sizeof(blobstorage_topicroot), 0 },             // AIA_BLOB_TOPIC_ROOT_KEY
 97 | };
 98 | 
 99 | bool AiaStoreBlob( const char* key, const uint8_t* blob, size_t size )
100 | {
101 |     bool process = false;
102 |     blobstorage_key_e k = AIA_BLOB_STORAGE_KEY_MAX;
103 | 
104 |     for( k = AIA_BLOB_STORAGE_KEY_START; blob && k < AIA_BLOB_STORAGE_KEY_MAX; ++k )
105 |     {
106 |         if( strncmp(key, blobstorage[ k ].key, strlen(key)) == 0 )
107 |         {
108 |             if( blobstorage[ k ].capacity >= size )
109 |             {
110 |                 memcpy( blobstorage[ k ].storage, blob, size );
111 |                 blobstorage[ k ].used_len = size;
112 |                 process = true;
113 |             }
114 |             else
115 |             {
116 |                 AiaLogError( "blob Store size error: key(%s), capacity(%u), size(%u)", key, blobstorage[k].capacity, size );
117 |             }
118 | 
119 |             break;
120 |         }
121 |     }
122 | 
123 |     if( !blob || k >= AIA_BLOB_STORAGE_KEY_MAX )
124 |     {
125 |         AiaLogError( "Invalid input: blob(%u) key(%s)", blob, key);
126 |     }
127 | 
128 |     return process;
129 | }
130 | 
131 | bool AiaLoadBlob( const char* key, uint8_t* const blob, size_t size )
132 | {
133 |     bool process = false;
134 |     blobstorage_key_e k = AIA_BLOB_STORAGE_KEY_MAX;
135 | 
136 |     for( k = AIA_BLOB_STORAGE_KEY_START; blob && k < AIA_BLOB_STORAGE_KEY_MAX; ++k )
137 |     {
138 |         if( strncmp(key, blobstorage[ k ].key, strlen(key)) == 0 )
139 |         {
140 |             if( blobstorage[ k ].used_len <= size )
141 |             {
142 |                 memcpy( blob, blobstorage[ k ].storage, blobstorage[k].used_len );
143 |                 process = true;
144 |             }
145 |             else
146 |             {
147 |                 AiaLogError( "blob load size error: key(%s), used(%u), size(%u)", key, blobstorage[k].used_len, size );
148 |             }
149 | 
150 |             break;
151 |         }
152 |     }
153 | 
154 |     if( !blob || k >= AIA_BLOB_STORAGE_KEY_MAX )
155 |     {
156 |         AiaLogError( "Invalid input: blob(%u) key(%s)", blob, key);
157 |     }
158 | 
159 |     return process;
160 | }
161 | 
162 | bool AiaBlobExists( const char* key )
163 | {
164 | 	bool existed = false;
165 |     blobstorage_key_e k = AIA_BLOB_STORAGE_KEY_MAX;
166 | 
167 |     for( k = AIA_BLOB_STORAGE_KEY_START;k < AIA_BLOB_STORAGE_KEY_MAX; ++k )
168 |     {
169 |         if( strncmp(key, blobstorage[ k ].key, strlen(key)) == 0 )
170 |         {
171 |             existed = true;
172 |             break;
173 |         }
174 |     }
175 | 
176 |     return existed;
177 | }
178 | 
179 | size_t AiaGetBlobSize( const char* key )
180 | {
181 |     size_t blob_size = 0;
182 |     blobstorage_key_e k = AIA_BLOB_STORAGE_KEY_MAX;
183 | 
184 |     for( k = AIA_BLOB_STORAGE_KEY_START; k < AIA_BLOB_STORAGE_KEY_MAX; ++k )
185 |     {
186 |         if( strncmp( key, blobstorage[ k ].key, strlen(key) ) == 0 )
187 |         {
188 |             blob_size = blobstorage[ k ].used_len;
189 |             break;
190 |         }
191 |     }
192 | 
193 |     if( k >= AIA_BLOB_STORAGE_KEY_MAX )
194 |     {
195 |         AiaLogError( "blob key error: %s", key );
196 |     }
197 | 
198 |     return blob_size;
199 | }
200 | 
201 | bool AiaStoreAlert( const char* alertToken, size_t alertTokenLen,
202 |                     AiaTimepointSeconds_t scheduledTime,
203 |                     AiaDurationMs_t duration, uint8_t alertType )
204 | {
205 |     if( !alertToken )
206 |     {
207 |         AiaLogError( "Null alertToken" );
208 |         return false;
209 |     }
210 |     if( alertTokenLen != AIA_ALERT_TOKEN_CHARS )
211 |     {
212 |         AiaLogError( "Invalid alert token length" );
213 |         return false;
214 |     }
215 | 
216 |     size_t allAlertsBytes = AiaGetAlertsSize();
217 |     size_t alertsBytesWithNewAlert =
218 |         allAlertsBytes + AIA_SIZE_OF_ALERT_IN_BYTES;
219 |     size_t startingOffset = allAlertsBytes;
220 |     size_t bytePosition;
221 |     bool updatingExistingAlert = false;
222 | 
223 |     /**
224 |      * Load all alerts from persistent storage. Allocated additional space
225 |      * for a new alert though in case the token we are trying to insert does
226 |      * not exist in persistent storage yet.
227 |      */
228 |     uint8_t* allAlertsBuffer = AiaCalloc( 1, alertsBytesWithNewAlert );
229 |     if( !allAlertsBuffer )
230 |     {
231 |         AiaLogError( "AiaCalloc failed, bytes=%zu.", alertsBytesWithNewAlert );
232 |         return false;
233 |     }
234 | 
235 |     if( !AiaLoadAlerts( allAlertsBuffer, allAlertsBytes ) )
236 |     {
237 |         AiaLogError( "AiaLoadBlob failed" );
238 |         AiaFree( allAlertsBuffer );
239 |         return false;
240 |     }
241 | 
242 |     /** Go through the tokens to find the first empty or matching one */
243 |     for( bytePosition = 0; bytePosition < alertsBytesWithNewAlert;
244 |          bytePosition += AIA_SIZE_OF_ALERT_IN_BYTES )
245 |     {
246 |         startingOffset = bytePosition;
247 |         if( '\0' == allAlertsBuffer[ bytePosition ] )
248 |         {
249 |             /** Found an empty token */
250 |             break;
251 |         }
252 |         else
253 |         {
254 |             /** Check if this token matches with what we are trying to insert */
255 |             if( !strncmp( (const char*)allAlertsBuffer + bytePosition,
256 |                           alertToken, alertTokenLen ) )
257 |             {
258 |                 updatingExistingAlert = true;
259 |                 break;
260 |             }
261 |         }
262 |     }
263 | 
264 |     /* Check if we have reached the alerts storage limit */
265 |     if( startingOffset == alertsBytesWithNewAlert )
266 |     {
267 |         AiaLogError(
268 |             "AiaStoreAlert failed: Maximum number of local alerts to store "
269 |             "reached." );
270 |         AiaFree( allAlertsBuffer );
271 |         return false;
272 |     }
273 | 
274 |     /** Write the new alert token */
275 |     uint8_t* newAlertOffset = allAlertsBuffer + startingOffset;
276 |     memcpy( newAlertOffset, alertToken, alertTokenLen );
277 | 
278 |     /** Write the other fields: scheduledTime, duration, alertType */
279 |     bytePosition = alertTokenLen;
280 |     for( size_t i = 0; i < sizeof( AiaTimepointSeconds_t );
281 |          ++i, bytePosition++ )
282 |     {
283 |         newAlertOffset[ bytePosition ] = ( scheduledTime >> ( i * 8 ) );
284 |     }
285 |     for( size_t i = 0; i < sizeof( AiaDurationMs_t ); ++i, bytePosition++ )
286 |     {
287 |         newAlertOffset[ bytePosition ] = ( duration >> ( i * 8 ) );
288 |     }
289 |     for( size_t i = 0; i < sizeof( uint8_t ); ++i, bytePosition++ )
290 |     {
291 |         newAlertOffset[ bytePosition ] = ( alertType >> ( i * 8 ) );
292 |     }
293 | 
294 |     /** Store the new blob in persistent storage */
295 |     size_t storeSize =
296 |         ( updatingExistingAlert ? allAlertsBytes : alertsBytesWithNewAlert );
297 |     /** Store the new blob in persistent storage */
298 |     if( !AiaStoreBlob( AIA_ALL_ALERTS_STORAGE_KEY_V0, allAlertsBuffer,
299 |                        storeSize ) )
300 |     {
301 |         AiaLogError( "AiaStoreBlob failed" );
302 |         AiaFree( allAlertsBuffer );
303 |         return false;
304 |     }
305 | 
306 |     AiaFree( allAlertsBuffer );
307 |     return true;
308 | }
309 | 
310 | bool AiaDeleteAlert( const char* alertToken, size_t alertTokenLen )
311 | {
312 |     if( !alertToken )
313 |     {
314 |         AiaLogError( "Null alertToken" );
315 |         return false;
316 |     }
317 |     if( alertTokenLen != AIA_ALERT_TOKEN_CHARS )
318 |     {
319 |         AiaLogError( "Invalid alert token length" );
320 |         return false;
321 |     }
322 | 
323 |     size_t allAlertsBytes = AiaGetAlertsSize();
324 |     size_t bytePosition;
325 |     bool deletingExistingAlert = false;
326 | 
327 |     /**
328 |      * Load all alerts from persistent storage.
329 |      */
330 |     uint8_t* allAlertsBuffer = AiaCalloc( 1, allAlertsBytes );
331 |     if( !allAlertsBuffer )
332 |     {
333 |         AiaLogError( "AiaCalloc failed, bytes=%zu.", allAlertsBytes );
334 |         return false;
335 |     }
336 | 
337 |     if( !AiaLoadAlerts( allAlertsBuffer, allAlertsBytes ) )
338 |     {
339 |         AiaLogError( "AiaLoadBlob failed" );
340 |         AiaFree( allAlertsBuffer );
341 |         return false;
342 |     }
343 | 
344 |     /** Go through the tokens to find the first empty or matching one */
345 |     for( bytePosition = 0; bytePosition < allAlertsBytes;
346 |          bytePosition += AIA_SIZE_OF_ALERT_IN_BYTES )
347 |     {
348 |         if( '\0' == allAlertsBuffer[ bytePosition ] )
349 |         {
350 |             /** Found an empty token */
351 |             break;
352 |         }
353 |         else
354 |         {
355 |             /** Check if this token matches with what we are trying to delete */
356 |             if( !strncmp( (const char*)allAlertsBuffer + bytePosition,
357 |                           alertToken, alertTokenLen ) )
358 |             {
359 |                 uint8_t* moveDst = allAlertsBuffer + bytePosition;
360 |                 uint8_t* moveSrc =
361 |                     allAlertsBuffer + bytePosition + AIA_SIZE_OF_ALERT_IN_BYTES;
362 |                 size_t moveBytes =
363 |                     allAlertsBytes -
364 |                     ( bytePosition + AIA_SIZE_OF_ALERT_IN_BYTES );
365 |                 memmove( moveDst, moveSrc, moveBytes );
366 |                 deletingExistingAlert = true;
367 |                 break;
368 |             }
369 |         }
370 |     }
371 | 
372 |     /** Store the new blob in persistent storage */
373 |     size_t storeSize =
374 |         ( deletingExistingAlert ? allAlertsBytes - AIA_SIZE_OF_ALERT_IN_BYTES
375 |                                 : allAlertsBytes );
376 |     /** Store the new blob */
377 |     if( !AiaStoreBlob( AIA_ALL_ALERTS_STORAGE_KEY_V0, allAlertsBuffer,
378 |                        storeSize ) )
379 |     {
380 |         AiaLogError( "AiaStoreBlob failed" );
381 |         AiaFree( allAlertsBuffer );
382 |         return false;
383 |     }
384 | 
385 |     AiaFree( allAlertsBuffer );
386 |     return true;
387 | }
388 | 
389 | bool AiaLoadAlert( char* alertToken, size_t alertTokenLen,
390 |                    AiaTimepointSeconds_t* scheduledTime,
391 |                    AiaDurationMs_t* duration, uint8_t* alertType,
392 |                    const uint8_t* allAlertsBuffer )
393 | {
394 |     if( !alertToken )
395 |     {
396 |         AiaLogError( "Null alertToken" );
397 |         return false;
398 |     }
399 |     if( !scheduledTime )
400 |     {
401 |         AiaLogError( "Null scheduledTime" );
402 |         return false;
403 |     }
404 |     if( !duration )
405 |     {
406 |         AiaLogError( "Null duration" );
407 |         return false;
408 |     }
409 |     if( !alertType )
410 |     {
411 |         AiaLogError( "Null alertType" );
412 |         return false;
413 |     }
414 |     if( !allAlertsBuffer )
415 |     {
416 |         AiaLogError( "Null allAlertsBuffer" );
417 |         return false;
418 |     }
419 |     if( alertTokenLen != AIA_ALERT_TOKEN_CHARS )
420 |     {
421 |         AiaLogError( "Invalid alert token length" );
422 |         return false;
423 |     }
424 | 
425 |     size_t bytePosition = 0;
426 |     *scheduledTime = 0;
427 |     *duration = 0;
428 |     *alertType = 0;
429 | 
430 |     memcpy( alertToken, allAlertsBuffer, alertTokenLen );
431 |     bytePosition += alertTokenLen;
432 | 
433 |     for( size_t i = 0; i < sizeof( AiaTimepointSeconds_t );
434 |          ++i, ++bytePosition )
435 |     {
436 |         *scheduledTime |= (unsigned)allAlertsBuffer[ bytePosition ]
437 |                           << ( i * 8 );
438 |     }
439 | 
440 |     for( size_t i = 0; i < sizeof( AiaDurationMs_t ); ++i, ++bytePosition )
441 |     {
442 |         *duration |= (unsigned)allAlertsBuffer[ bytePosition ] << ( i * 8 );
443 |     }
444 | 
445 |     for( size_t i = 0; i < sizeof( uint8_t ); ++i, ++bytePosition )
446 |     {
447 |         *alertType |= (unsigned)allAlertsBuffer[ bytePosition ] << ( i * 8 );
448 |     }
449 | 
450 |     return true;
451 | }
452 | 
453 | bool AiaLoadAlerts( uint8_t* allAlerts, size_t size )
454 | {
455 |     if( !AiaAlertsBlobExists() )
456 |     {
457 |         if( size != 0 )
458 |         {
459 |             AiaLogError( "Alerts blob with size %zu does not exist", size );
460 |             return false;
461 |         }
462 |         else
463 |         {
464 |             return true;
465 |         }
466 |     }
467 |     else
468 |     {
469 |         return AiaLoadBlob( AIA_ALL_ALERTS_STORAGE_KEY_V0, allAlerts, size );
470 |     }
471 | }
472 | 
473 | size_t AiaGetAlertsSize()
474 | {
475 |     return AiaGetBlobSize( AIA_ALL_ALERTS_STORAGE_KEY_V0 );
476 | }
477 | 
478 | bool AiaAlertsBlobExists()
479 | {
480 |     return AiaBlobExists( AIA_ALL_ALERTS_STORAGE_KEY_V0 );
481 | }
482 | 


--------------------------------------------------------------------------------
/ports/IoT/include/iot/aia_iot_config.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *     http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | #ifndef AIA_IOT_CONFIG_H_
 18 | #ifdef __cplusplus
 19 | extern "C" {
 20 | #endif
 21 | #define AIA_IOT_CONFIG_H_
 22 | 
 23 | #include <clock/aia_clock_config.h>
 24 | 
 25 | /* The IoT config header */
 26 | #include <iot_config.h>
 27 | 
 28 | /* IoT SDK headers */
 29 | #include <iot_json_utils.h>
 30 | #include <iot_atomic.h>
 31 | #include <iot_logging.h>
 32 | #include <iot_mqtt.h>
 33 | #include <platform/iot_threads.h>
 34 | #include <types/iot_mqtt_types.h>
 35 | #include <types/iot_taskpool_types.h>
 36 | 
 37 | #include <string.h>
 38 | 
 39 | /** Simple macro to stringify a parameter. */
 40 | #define AIA_STRINGIFY( x ) #x
 41 | 
 42 | /**
 43 |  * Second layer of macro to ensure @c AIA_CONFIG_STRINGIFY() is expanded at the
 44 |  * caller's location rather than here.
 45 |  */
 46 | #define AIA_TOSTRING( x ) AIA_STRINGIFY( x )
 47 | 
 48 | /**
 49 |  * Simple printf-style logging macros which automatically prepends the file
 50 |  * name and line number.
 51 |  */
 52 | /** @{ */
 53 | #define IOT_LOG_LEVEL_AIA IOT_LOG_INFO
 54 | #define AiaLog( Level, ... ) \
 55 |     IotLog_Generic( IOT_LOG_LEVEL_AIA, "AIA", Level, NULL, __VA_ARGS__ )
 56 | #define AiaLogDebug( ... ) AiaLog( IOT_LOG_DEBUG, __VA_ARGS__ )
 57 | #define AiaLogError( ... ) AiaLog( IOT_LOG_ERROR, __VA_ARGS__ )
 58 | #define AiaLogInfo( ... ) AiaLog( IOT_LOG_INFO, __VA_ARGS__ )
 59 | #define AiaLogWarn( ... ) AiaLog( IOT_LOG_WARN, __VA_ARGS__ )
 60 | 
 61 | #ifdef AIA_EMIT_SENSITIVE_LOGS
 62 | 
 63 | #define AIA_SENSITIVE_TAG "AIA_SENSITIVE"
 64 | #define AiaLogSensitive( ... )                                             \
 65 |     IotLog_Generic( IOT_LOG_DEBUG, AIA_SENSITIVE_TAG, IOT_LOG_DEBUG, NULL, \
 66 |                     __VA_ARGS__ )
 67 | 
 68 | #else
 69 | #define AiaLogSensitive( ... )
 70 | 
 71 | #endif
 72 | /** @} */
 73 | 
 74 | /** Macros and typedefs for task pool. */
 75 | /** @{ */
 76 | typedef IotTaskPoolInfo_t AiaTaskPoolInfo_t;
 77 | typedef IotTaskPoolError_t AiaTaskPoolError_t;
 78 | typedef IotTaskPoolJobStatus_t AiaTaskPoolJobStatus_t;
 79 | typedef IotTaskPoolJobStorage_t AiaTaskPoolJobStorage_t;
 80 | typedef IotTaskPoolJob_t AiaTaskPoolJob_t;
 81 | #define AiaTaskPool( MEMBER ) IotTaskPool_##MEMBER
 82 | #define AiaTaskPool_t AiaTaskPool( t )
 83 | #define IotTaskPool_HEADER <iot_taskpool.h>
 84 | #define IotTaskPool_INITIALIZER IOT_TASKPOOL_INITIALIZER
 85 | #define IotTaskPool_INFO_INITIALIZER IOT_TASKPOOL_INFO_INITIALIZER
 86 | #define IotTaskPool_JOB_STORAGE_INITIALIZER IOT_TASKPOOL_JOB_STORAGE_INITIALIZER
 87 | #define IotTaskPool_JOB_INITIALIZER IOT_TASKPOOL_JOB_INITIALIZER
 88 | /** @} */
 89 | 
 90 | /**
 91 |  * Determine if the AiaTaskPool return error is success.
 92 |  *
 93 |  * @param error The return error to evaluate.
 94 |  * @return @c true if @c error indicates success, else @c false.
 95 |  */
 96 | static inline bool AiaTaskPoolSucceeded( AiaTaskPoolError_t error )
 97 | {
 98 |     return error == IOT_TASKPOOL_SUCCESS;
 99 | }
100 | 
101 | /**
102 |  * This function searches for the specified @c jsonkey in the json @c
103 |  * jsonDocument string provided.  If found, @c jsonValue and @c
104 |  * jsonValueLength are updated to indicate where the value for that key starts
105 |  * and ends.
106 |  * @note In a complex nested JSON @c jsonDocument, calling this function with
107 |  * the @c jsonkey for a complex object will return the entire complex object as
108 |  * the @c jsonValue.  This allows a recursive decent pattern where this
109 |  * function can subsequently be called with the complex object that was found as
110 |  * the new @c jsonDocument, allowing the application to search for a @c
111 |  * jsonkey within that object.
112 |  *
113 |  * @param jsonDocument A buffer containing the JSON document text to search in
114 |  * (does not need to be '\0' terminated).
115 |  * @param jsonDocumentLength The length of @c jsonDocument (does not need to
116 |  * include a terminating '\0').
117 |  * @param jsonkey A buffer containing the key to search for (does not need to
118 |  * be '\0' terminated).
119 |  * @param jsonkeyLength The length of @c jsonkey (does not need to include a
120 |  * terminating '\0').
121 |  * @param jsonValue A pointer to a @c const @c char pointer that can be used to
122 |  * return the location @ jsonkey's value starts at.
123 |  * @param jsonValueLength A pointer to a @c size_t that can be used to return
124 |  * the length of @c jsonkey's value (not including a terminating '\0').
125 |  * @return @c true if @c jsonkey was found successfully, else @c false.
126 |  * TODO: Handle arrays in AiaFindJsonValue (ADSER-1494)
127 |  */
128 | inline bool AiaFindJsonValue( const char* jsonDocument,
129 |                               size_t jsonDocumentLength, const char* jsonKey,
130 |                               size_t jsonKeyLength, const char** jsonValue,
131 |                               size_t* jsonValueLength )
132 | {
133 |     return jsonDocument && jsonKey && jsonDocumentLength && jsonKeyLength &&
134 |             IotJsonUtils_FindJsonValue( jsonDocument, jsonDocumentLength, jsonKey,
135 |                                       jsonKeyLength, jsonValue,
136 |                                       jsonValueLength );
137 | }
138 | 
139 | /**
140 |  * Implements an atomic load function by performing a bitwise OR operation with
141 |  * all zeroes.
142 |  * TODO: ADSER-1517 implement generic and compiler-specific version using actual
143 |  * atomic load instructions
144 |  */
145 | static inline uint32_t AiaAtomic_Load_u32( uint32_t* operand )
146 | {
147 |     return Atomic_OR_u32( operand, 0 );
148 | }
149 | 
150 | /**
151 |  * Implements an atomic store operation by continuously performing a
152 |  * compare-and-swap operation until the value is successfully written.
153 |  * TODO: ADSER-1517 implement generic and compiler-specific version using actual
154 |  * atomic store instructions
155 |  */
156 | static inline void AiaAtomic_Store_u32( uint32_t* operand, uint32_t val )
157 | {
158 |     while( !Atomic_CompareAndSwap_u32( operand, val, *operand ) )
159 |     {
160 |     }
161 | }
162 | 
163 | /**
164 |  * A function which performs an arithmetic atomic addition operation.
165 |  * TODO: ADSER-1517 implement generic and compiler-specific version using actual
166 |  * atomic add instructions
167 |  *
168 |  * @param[in,out] operand Pointer to the augend and where the sum is stored.
169 |  * @param[in] addendum Value to add to the augend.
170 |  *
171 |  * @return The initial value at `operand`.
172 |  */
173 | static inline uint32_t AiaAtomic_Add_u32( uint32_t* operand, uint32_t addendum )
174 | {
175 |     return Atomic_Add_u32( operand, addendum );
176 | }
177 | 
178 | /**
179 |  * An unsigned, integral type used to represent indexes in the stream. Note that
180 |  * @c AiaDataStreamIndex_t wrapping is not checked for,so this type must
181 |  * be large enough to guarantee that no wrapping will occur over the practical
182 |  * lifespan of the AiaDataStreamBuffer_t instance.
183 |  */
184 | typedef uint32_t AiaDataStreamIndex_t;
185 | 
186 | static const AiaDataStreamIndex_t AIA_DATA_STREAM_INDEX_MAX = UINT32_MAX;
187 | 
188 | /**
189 |  * An atomic version of @c AiaDataStreamIndex_t. Note that this type is
190 |  * not inherently atomic and must be accessed using the @c
191 |  * AiaDataStreamAtomicIndex_Load() and @c
192 |  * AiaDataStreamAtomicIndex_Store() functions.
193 |  */
194 | typedef AiaDataStreamIndex_t AiaDataStreamAtomicIndex_t;
195 | 
196 | /** A function used to atomically load the value of an @c
197 |  * AiaDataStreamIndex_t. */
198 | static inline AiaDataStreamIndex_t AiaDataStreamAtomicIndex_Load(
199 |     AiaDataStreamIndex_t* operand )
200 | {
201 |     return AiaAtomic_Load_u32( operand );
202 | }
203 | 
204 | /**
205 |  * A function used to atomically store a value into an @c
206 |  * AiaDataStreamIndex_t.
207 |  */
208 | static inline void AiaDataStreamAtomicIndex_Store(
209 |     AiaDataStreamIndex_t* operand, AiaDataStreamIndex_t newValue )
210 | {
211 |     AiaAtomic_Store_u32( operand, newValue );
212 | }
213 | 
214 | /**
215 |  * A function which performs an arithmetic atomic addition operation.
216 |  *
217 |  * @param[in,out] operand Pointer to the augend and where the sum is stored.
218 |  * @param[in] addendum Value to add to the augend.
219 |  *
220 |  * @return The initial value at `operand`.
221 |  */
222 | static inline AiaDataStreamIndex_t AiaDataStreamAtomicIndex_Add(
223 |     AiaDataStreamIndex_t* operand, AiaDataStreamIndex_t addendum )
224 | {
225 |     return AiaAtomic_Add_u32( operand, addendum );
226 | }
227 | 
228 | /**
229 |  * An atomic boolean abstraction. Note that this type is not inherently atomic
230 |  * and must be accessed using the @c AiaAtomicBool_Set, @c
231 |  * AiaAtomicBool_Clear and @c AiaAtomicBool_Load functions.
232 |  */
233 | typedef uint32_t AiaAtomicBool_t;
234 | 
235 | /** A function used to set the value of @c AiaAtomicBool_t. */
236 | static inline void AiaAtomicBool_Set( AiaAtomicBool_t* operand )
237 | {
238 |     AiaAtomic_Store_u32( operand, 1 );
239 | }
240 | 
241 | /** A function used to clear the value of an @c AiaAtomicBool_t. */
242 | static inline void AiaAtomicBool_Clear( AiaAtomicBool_t* operand )
243 | {
244 |     AiaAtomic_Store_u32( operand, 0 );
245 | }
246 | 
247 | /** A function used to load the value of an @c AiaAtomicBool_t. */
248 | static inline AiaAtomicBool_t AiaAtomicBool_Load( AiaAtomicBool_t* operand )
249 | {
250 |     return AiaAtomic_Load_u32( operand );
251 | }
252 | 
253 | /** Macros for mutexes. */
254 | /** @{ */
255 | #define AiaMutex( MEMBER ) IotMutex_##MEMBER
256 | #define IotMutex_HEADER <platform/iot_threads.h>
257 | #define AiaMutex_t AiaMutex( t )
258 | /** @} */
259 | 
260 | /** Macros for Semaphores. */
261 | /** @{ */
262 | #define AiaSemaphore( MEMBER ) IotSemaphore_##MEMBER
263 | #define IotSemaphore_HEADER <platform/iot_threads.h>
264 | #define AiaSemaphore_t AiaSemaphore( t )
265 | /** @} */
266 | 
267 | /**
268 |  * Macros for doubly-linked lists.
269 |  *
270 |  * Example Usage:
271 |  * @code{c}
272 |  * #include AiaListDouble( HEADER )
273 |  *
274 |  * void foo( void)
275 |  * {
276 |  *     AiaListDouble_t list;
277 |  *     AiaListDouble( Link_t ) link = AiaListDouble( LINK_INITIALIZER );
278 |  *     AiaListDouble( InsertTail )( &list, &link );
279 |  *     AiaAssert(!AiaListDouble( IsEmpty )( &list );
280 |  *     AiaListDouble( RemoveAll )( &list, NULL, 0 );
281 |  * }
282 |  * @endcode
283 |  */
284 | /** @{ */
285 | #define AiaContainerConcat( TYPE, MEMBER ) TYPE##_##MEMBER
286 | #define AiaContainer( TYPE, MEMBER ) AiaContainerConcat( TYPE, MEMBER )
287 | #define IotListDouble_HEADER <iot_linear_containers.h>
288 | #define AiaListDouble( MEMBER ) AiaContainer( IotListDouble, MEMBER )
289 | #define AiaListDouble_t AiaListDouble( t )
290 | #define IotListDouble_Link_t IotLink_t
291 | #define IotListDouble_LINK_INITIALIZER IOT_LINK_INITIALIZER
292 | #define IotListDouble_ForEach IotContainers_ForEach
293 | /** @} */
294 | 
295 | #define AiaClock( MEMBER ) IotClock_##MEMBER
296 | #define IotClock_HEADER <platform/iot_clock.h>
297 | 
298 | /** Macros and typedefs for timers. */
299 | /** @{ */
300 | /** IotClock_ARM minimal starting interval **/
301 | #define AIA_CLOCK_ARM_MS_MIN    10
302 | #define AIA_CLOCK_ARM_START_MIN(_start_ms) (AIA_CLOCK_ARM_MS_MIN > _start_ms ? AIA_CLOCK_ARM_MS_MIN : _start_ms)
303 | #define AiaClock_Timer_Create IotClock_TimerCreate
304 | #define AiaClock_Timer_Destroy IotClock_TimerDestroy
305 | #define AiaClock_Timer_Arm(_pt, _start, _duration) IotClock_TimerArm(_pt, AIA_CLOCK_ARM_START_MIN(_start), _duration)
306 | #define AiaClock_Timer_HEADER IotClock_HEADER
307 | #define AiaTimer( MEMBER ) AiaClock_Timer_##MEMBER
308 | typedef IotTimer_t AiaTimer_t;
309 | /** @} */
310 | 
311 | /**
312 |  * Typedefs to handle MQTT communications.
313 |  */
314 | /** @{ */
315 | typedef IotMqttConnection_t AiaMqttConnectionPointer_t;
316 | typedef IotMqttQos_t AiaMqttQos_t;
317 | typedef IotMqttCallbackParam_t AiaMqttCallbackParam_t;
318 | static const AiaMqttQos_t AIA_MQTT_QOS0 = IOT_MQTT_QOS_0;
319 | /** @} */
320 | 
321 | /**
322 |  * The timeout for MQTT operations.
323 |  */
324 | #define MQTT_TIMEOUT_MS 5000
325 | 
326 | /**
327 |  * Retry for QOS 1 MQTT operations.
328 |  */
329 | /** @{ */
330 | static const AiaDurationMs_t MQTT_RETRY_TIMEOUT_MS = 2000;
331 | static const size_t MQTT_RETRY_LIMIT = 10;
332 | /** @} */
333 | 
334 | /**
335 |  * Following type is used to handle MQTT callbacks.
336 |  */
337 | typedef void ( *AiaMqttTopicHandler_t )( void*, AiaMqttCallbackParam_t* );
338 | 
339 | /**
340 |  * Subscribes to a given MQTT connection topic with the provided parameters.
341 |  *
342 |  * @param connection Pointer to the MQTT connection to use for the subscription.
343 |  * @param qos Quality of Service during subscription.
344 |  * @param topic The topic to subscribe to.
345 |  * @param handler The callback function to invoke after subscription is done.
346 |  * @param userData Context of the callback function.
347 |  * @return @c true if subscription is successful, else @ false.
348 |  */
349 | inline bool AiaMqttSubscribe( AiaMqttConnectionPointer_t connection,
350 |                               AiaMqttQos_t qos, const char* topic,
351 |                               AiaMqttTopicHandler_t handler, void* userData )
352 | {
353 |     IotMqttSubscription_t topicSubscription;
354 |     topicSubscription.qos = qos;
355 |     topicSubscription.pTopicFilter = topic;
356 |     topicSubscription.topicFilterLength = (uint16_t)strlen( topic );
357 |     topicSubscription.callback.function = handler;
358 |     topicSubscription.callback.pCallbackContext = userData;
359 | 
360 |     return IOT_MQTT_SUCCESS ==
361 |            IotMqtt_TimedSubscribe( connection, &topicSubscription,
362 |                                    1, /* Subscribe to one topic at once */
363 |                                    0, /* No flags */
364 |                                    MQTT_TIMEOUT_MS ); /* Timeout - 5 seconds */
365 | }
366 | 
367 | /**
368 |  * Unsubscribes from a given MQTT connection topic with the provided parameters.
369 |  *
370 |  * @param connection Pointer to the MQTT connection to use for the
371 |  * unsubscription.
372 |  * @param qos Quality of Service during unsubscription.
373 |  * @param topic The topic to unsubscribe from.
374 |  * @param handler The callback function to invoke after unsubscription is done.
375 |  * @param userData Context of the callback function.
376 |  * @return @c true if unsubscription is successful, else @ false.
377 |  */
378 | inline bool AiaMqttUnsubscribe( AiaMqttConnectionPointer_t connection,
379 |                                 AiaMqttQos_t qos, const char* topic,
380 |                                 AiaMqttTopicHandler_t handler, void* userData )
381 | {
382 |     IotMqttSubscription_t topicSubscription;
383 |     topicSubscription.qos = qos;
384 |     topicSubscription.pTopicFilter = topic;
385 |     topicSubscription.topicFilterLength = (uint16_t)strlen( topic );
386 |     topicSubscription.callback.function = handler;
387 |     topicSubscription.callback.pCallbackContext = userData;
388 | 
389 |     return IOT_MQTT_SUCCESS == IotMqtt_TimedUnsubscribe(
390 |                                    connection, &topicSubscription,
391 |                                    1, /* Unsubscribe from one topic at once */
392 |                                    0, /* No flags */
393 |                                    MQTT_TIMEOUT_MS ); /* Timeout - 5 seconds */
394 | }
395 | 
396 | /**
397 |  * Publishes to a given MQTT topic with the provided parameters.
398 |  * @note Uses a blocking variant of publish when using QOS 1.
399 |  *
400 |  * @param connection Pointer to the MQTT connection to use for the publish.
401 |  * @param qos Quality of Service for publish.
402 |  * @param topic The topic to publish to.
403 |  * @param topicLength The length of @c topic, or 0 if @c topic is
404 |  *     null-terminated.
405 |  * @param message The message to publish.
406 |  * @param messageLength The length of @c message, or 0 if @c message is
407 |  *     null-terminated.
408 |  * @return @c true if publish is successful, else @c false.
409 |  */
410 | bool AiaMqttPublish( AiaMqttConnectionPointer_t connection, AiaMqttQos_t qos,
411 |                      const char* topic, size_t topicLength, const void* message,
412 |                      size_t messageLength );
413 | 
414 | #ifdef __cplusplus
415 | }
416 | #endif
417 | #endif /* ifndef AIA_IOT_CONFIG_H_ */
418 | 


--------------------------------------------------------------------------------
/demos/aia/aia_sample_app.c:
--------------------------------------------------------------------------------
   1 | /*
   2 |  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   3 |  *
   4 |  * Licensed under the Apache License, Version 2.0 (the "License");
   5 |  * you may not use this file except in compliance with the License.
   6 |  * You may obtain a copy of the License at
   7 |  *
   8 |  *     http://www.apache.org/licenses/LICENSE-2.0
   9 |  *
  10 |  * Unless required by applicable law or agreed to in writing, software
  11 |  * distributed under the License is distributed on an "AS IS" BASIS,
  12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 |  * See the License for the specific language governing permissions and
  14 |  * limitations under the License.
  15 |  */
  16 | 
  17 | /**
  18 |  * @file aia_sample_app.c
  19 |  * @brief Aia sample app.
  20 |  */
  21 | 
  22 | /* The config header is always included first. */
  23 | #include <aia_config.h>
  24 | 
  25 | #include "aia_sample_app.h"
  26 | 
  27 | #include <aia_application_config.h>
  28 | #include <aia_capabilities_config.h>
  29 | #include <aiaalertmanager/aia_alert_slot.h>
  30 | #include <aiaclient/aia_client.h>
  31 | #include <aiaconnectionmanager/aia_connection_constants.h>
  32 | #include <aiacore/aia_mbedtls_threading.h>
  33 | #include <aiacore/aia_random_mbedtls.h>
  34 | #include <aiacore/aia_utils.h>
  35 | #include <aiacore/capabilities_sender/aia_capabilities_sender.h>
  36 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer.h>
  37 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer_reader.h>
  38 | #include <aiacore/data_stream_buffer/aia_data_stream_buffer_writer.h>
  39 | #include <aiaexceptionmanager/aia_exception_code.h>
  40 | #include <aiamicrophonemanager/aia_microphone_constants.h>
  41 | #include <aiaregistrationmanager/aia_registration_manager.h>
  42 | #include <aiauxmanager/aia_ux_state.h>
  43 | 
  44 | //#define AIA_DEMO_AUDIO_ENABLE
  45 | #ifdef AIA_DEMO_AUDIO_ENABLE
  46 | #include <aiaalerttonesynthesizer/aia_alert_tone.h>
  47 | #include <aiaopusdecoder/aia_opus_decoder.h>
  48 | #include <aiaportaudiomicrophone/aia_portaudio_microphone.h>
  49 | #include <aiaportaudiospeaker/aia_portaudio_speaker.h>
  50 | #endif
  51 | 
  52 | #include AiaTaskPool( HEADER )
  53 | #include AiaTimer( HEADER )
  54 | 
  55 | /* Platform layer includes. */
  56 | #include <inttypes.h>
  57 | #include "event_groups.h"
  58 | #include "platform/iot_clock.h"
  59 | #include "platform/iot_threads.h"
  60 | 
  61 | /** Information for registration */
  62 | #define AIA_REG_HTTPS_AWS_ACCOUNT_ID "012345678901"
  63 | #define AIA_REG_HTTPS_LWA_CLIENT_ID "xxxxxxxxxxxx"
  64 | #define AIA_REG_HTTPS_LWA_REFRESH_TOKEN "xxxxxxxxxxx"
  65 | 
  66 | extern const char *g_aiaIotEndpoint;
  67 | extern const char *g_aiaClientId;
  68 | extern const char *g_aiaAwsAccountId;
  69 | extern const char *g_aiaStorageFolder;
  70 | extern char *g_aiaLwaRefreshToken;
  71 | extern char *g_aiaLwaClientId;
  72 | 
  73 | /** The amount of audio data to keep in the microphone buffer. */
  74 | #define AMOUNT_OF_AUDIO_DATA_IN_MIC_BUFFER ( (AiaDurationMs_t)10000 )
  75 | 
  76 | /** Buffer size in samples. */
  77 | #define MIC_BUFFER_SIZE_IN_SAMPLES \
  78 |     ( ( size_t )( AMOUNT_OF_AUDIO_DATA_IN_MIC_BUFFER * AIA_MICROPHONE_SAMPLE_RATE_HZ / AIA_MS_PER_SECOND ) )
  79 | 
  80 | #ifdef AIA_DEMO_AUDIO_ENABLE
  81 | /**
  82 |  * Sample app pushes speaker data through PortAudio speaker which publishes
  83 |  * @c SAMPLE_RATE samples per second. We calculate here how long it takes in
  84 |  * milliseconds to publish all the samples in a given alert tone frame.
  85 |  */
  86 | #define AIA_ALERT_TONE_FRAME_LENGTH_IN_MS \
  87 |     ( ( AiaDurationMs_t )( ( AIA_ALERT_TONE_FRAME_LENGTH * AIA_MS_PER_SECOND ) / SAMPLE_RATE ) )
  88 | #endif
  89 | 
  90 | /** AIA Demo Cases **/
  91 | typedef enum _AIA_DEMO_CASES_E
  92 | {
  93 |     AIA_DEMO_CASE_CONNECT = 0,
  94 |     AIA_DEMO_CASE_CAPABILITY,
  95 |     AIA_DEMO_CASE_SYNC_ST,
  96 |     AIA_DEMO_CASE_SYNC_TIME,
  97 |     AIA_DEMO_CASE_HOLD_TO_TALK_START,
  98 |     AIA_DEMO_CASE_HOLD_TO_TALK_STOP,
  99 |     AIA_DEMO_CASE_DISCONNECT,
 100 | } AIA_DEMO_CASES_E;
 101 | 
 102 | char *AIA_DEMO_CASE_TO_STRING[] = {
 103 |     "AIA_DEMO_CASE_CONNECT",   "AIA_DEMO_CASE_CAPABILITY",         "AIA_DEMO_CASE_SYNC_ST",
 104 |     "AIA_DEMO_CASE_SYNC_TIME", "AIA_DEMO_CASE_HOLD_TO_TALK_START", "AIA_DEMO_CASE_HOLD_TO_TALK_STOP",
 105 |     "AIA_DEMO_CASE_DISCONNECT"
 106 | };
 107 | 
 108 | /** AIA Demo Events **/
 109 | #define AIA_EVENT_CONNECTED ( 0x1 << 0 )
 110 | #define AIA_EVENT_DISCONNECTED ( 0x1 << 1 )
 111 | #define AIA_EVENT_CAP_CHANGED ( 0x1 << 2 )
 112 | #define AIA_EVENT_REGISTERED ( 0x1 << 3 )
 113 | #define AIA_EVENT_DUMMY ( 0x1 << 4 )
 114 | 
 115 | static EventGroupHandle_t aia_eg;
 116 | 
 117 | #define AIA_DEMO_EG_WAIT( _event, _ms ) \
 118 |     xEventGroupWaitBits( aia_eg, _event, true, false, _ms == 0 ? portMAX_DELAY : pdMS_TO_TICKS( _ms ) )
 119 | #define AIA_DEMO_EG_DUMMY_WAIT_WAIT( _ms ) AIA_DEMO_EG_WAIT( AIA_EVENT_DUMMY | AIA_EVENT_DISCONNECTED, _ms )
 120 | #define AIA_DEMO_EG_SET( _event ) xEventGroupSetBits( aia_eg, _event )
 121 | #define AIA_DEMO_EG_GET() xEventGroupGetBits( aia_eg )
 122 | 
 123 | /** Buffer size in bytes; */
 124 | static const size_t MIC_BUFFER_SIZE_IN_BYTES = MIC_BUFFER_SIZE_IN_SAMPLES * AIA_MICROPHONE_BUFFER_WORD_SIZE;
 125 | 
 126 | /** Arbitrary. */
 127 | static const size_t MIC_NUM_READERS = 2;
 128 | 
 129 | /** @name Methods that simply print states to stdout. */
 130 | /** @{ */
 131 | static void onAiaConnectionSuccessfulSimpleUI( void *userData );
 132 | static void onAiaDisconnectedSimpleUI( void *userData, AiaConnectionOnDisconnectCode_t code );
 133 | static void onAiaConnectionRejectedSimpleUI( void *userData, AiaConnectionOnConnectionRejectionCode_t code );
 134 | static void onAiaExceptionReceivedSimpleUI( void *userData, AiaExceptionCode_t code );
 135 | static void onAiaCapabilitiesStateChangedSimpleUI( AiaCapabilitiesSenderState_t state, const char *description,
 136 |                                                    size_t descriptionLen, void *userData );
 137 | static void onUXStateChangedSimpleUI( AiaUXState_t state, void *userData );
 138 | static void onAiaRegistrationSuccess( void *userData );
 139 | static void onAiaRegistrationFailed( void *userData, AiaRegistrationFailureCode_t code );
 140 | /** @} */
 141 | 
 142 | /**
 143 |  * Callback that allows the PortAudio speaker to indicate it is ready for
 144 |  * audio data again.
 145 |  *
 146 |  * @param userData Context to be associated with the callback.
 147 |  */
 148 | static void onPortAudioSpeakerReadyAgain( void *userData );
 149 | 
 150 | #ifdef AIA_ENABLE_SPEAKER
 151 | /**
 152 |  * Callback from the underlying @c AiaSpeakerManager_t to push frames for
 153 |  * playback.
 154 |  *
 155 |  * @param buf The buffer to play.
 156 |  * @param size Size of @c buf
 157 |  * @param userData Context for this callback.
 158 |  */
 159 | static bool onSpeakerFramePushedForPlayback( const void *buf, size_t size, void *userData );
 160 | 
 161 | /**
 162 |  * Callback from the underlying @c AiaSpeakerManager_t to change the volume.
 163 |  *
 164 |  * @param newVolume The new volume, between @c AIA_MIN_VOLUME and @c
 165 |  * AIA_MAX_VOLUME, inclusive.
 166 |  * @param userData Context for this callback. This should point to an @c
 167 |  * AiaPortAudioSpeaker_t.
 168 |  */
 169 | static void onSpeakerVolumeChanged( uint8_t newVolume, void *userData );
 170 | 
 171 | /**
 172 |  * Callback from the underlying @c AiaSpeakerManager_t to start offline alert
 173 |  * playback.
 174 |  *
 175 |  * @param offlineAlert The offline alert to play the alert tone for.
 176 |  * @param userData Context for this callback.
 177 |  * @return @c true If offline alert playback has successfully started or @c
 178 |  * false otherwise.
 179 |  */
 180 | static bool onStartOfflineAlertTone( const AiaAlertSlot_t* offlineAlert,
 181 |                                      void* userData );
 182 | 
 183 | /**
 184 |  * This is a periodic function controlled by the @c offlineAlertPlaybackTimer.
 185 |  * It is responsible for pushing a frame to the speaker for the offline alert
 186 |  * tone every time it is invoked.
 187 |  *
 188 |  * @param userData Context for this function.
 189 |  */
 190 | static void onPlayOfflineAlertTone( void* userData );
 191 | 
 192 | /**
 193 |  * Callback from the underlying @c AiaSpeakerManager_t to stop offline alert
 194 |  * playback.
 195 |  *
 196 |  * @param userData Context for this callback.
 197 |  * @return @c true If offline alert playback has been successfully stopped or @c
 198 |  * false otherwise.
 199 |  */
 200 | static bool onStopOfflineAlertTone( void* userData );
 201 | #endif
 202 | 
 203 | /**
 204 |  * Processes inputted command from a user.
 205 |  *
 206 |  * @param c The command inputted as a character to process.
 207 |  * @param[out] exit This is set to @c true if a user wishes to quit the
 208 |  * application.
 209 |  * @param sampleApp The @c AiaSampleApp_t that will process received commands.
 210 |  */
 211 | static void processDemoCase( AIA_DEMO_CASES_E c, AiaSampleApp_t *sampleApp );
 212 | 
 213 | /**
 214 |  * Initialize the AIA Client.
 215 |  *
 216 |  * @param sampleApp The @c AiaSampleApp_t to initialize the client for.
 217 |  */
 218 | static bool initAiaClient( AiaSampleApp_t *sampleApp );
 219 | 
 220 | /**
 221 |  * Register with AIA.
 222 |  *
 223 |  * @param sampleApp The @c AiaSampleApp_t to initialize the client for.
 224 |  */
 225 | static bool registerAia( AiaSampleApp_t *sampleApp );
 226 | 
 227 | /**
 228 |  * Container of all components necessary for the client to run.
 229 |  */
 230 | struct AiaSampleApp
 231 | {
 232 |     /** Handle to a connected MQTT connection. */
 233 |     AiaMqttConnectionPointer_t mqttConnection;
 234 | 
 235 |     /** Raw underlying buffer that will be used to hold microphone data. */
 236 |     void *rawMicrophoneBuffer;
 237 | 
 238 |     /** This buffer will be used to hold microphone data. */
 239 |     AiaMicrophoneBuffer_t *microphoneBuffer;
 240 | 
 241 |     /** This will be used by the underlying @c aiaClient to stream microphone
 242 |      * data to Aia when needed. */
 243 |     AiaDataStreamReader_t *microphoneBufferReader;
 244 | 
 245 |     /** Used to capture and write microphone data to the @c microphoneBuffer. */
 246 |     AiaMicrophoneBufferWriter_t *microphoneBufferWriter;
 247 | 
 248 |     /** The Aia client. */
 249 |     AiaClient_t *aiaClient;
 250 | 
 251 |     /** The registration manager used to register the Aia client. */
 252 |     AiaRegistrationManager_t *registrationManager;
 253 |     
 254 |     /** Whether to skip publishing events to Aia service */
 255 |     AiaAtomicBool_t shouldPublishEvent;
 256 | 
 257 | #ifdef AIA_ENABLE_SPEAKER
 258 |     /** Whether speaker is ready to accept new frames */
 259 |     AiaAtomicBool_t isSpeakerReady;
 260 | 
 261 |     /** Whether the offline alert being currently played should be removed
 262 |      * from persistent storage */
 263 |     AiaAtomicBool_t shouldDeleteOfflineAlert;
 264 | 
 265 |     /** Timer that controls how often a frame should be pushed to the speaker
 266 |      * while playing an offline alert. */
 267 |     AiaTimer_t offlineAlertPlaybackTimer;
 268 | 
 269 |     /** Pointer to the offline alert that is currently being played */
 270 |     AiaAlertSlot_t* offlineAlertInProgress;
 271 | 
 272 |     /** Keeps track of the time offline alert playback started at */
 273 |     AiaTimepointSeconds_t offlineAlertPlaybackStartTime;
 274 | #endif
 275 | 
 276 | #ifdef AIA_DEMO_AUDIO_ENABLE
 277 |     /** Whether microphone is currently being recorded locally. */
 278 |     bool isMicrophoneActive;
 279 | 
 280 |     /** Whether an interaction (hold-to-talk) is currently occurring. */
 281 |     bool isMicrophoneOpen;
 282 | 
 283 |     /** The PortAudio microphone wrapper. */
 284 |     AiaPortAudioMicrophoneRecorder_t *portAudioMicrophoneRecorder;
 285 | 
 286 |     /** Opus decoder to decode speaker frames into PCM data. */
 287 |     AiaOpusDecoder_t *opusDecoder;
 288 | 
 289 |     /** PortAudio based speaker to play PCM data. */
 290 |     AiaPortAudioSpeaker_t *portAudioSpeaker;
 291 | #endif
 292 | 
 293 |     /** A flag is used to store whether this client connects to Aia */
 294 |     bool isAiaClientConnected;
 295 | 
 296 |     /** A flag is used to check whether this demo should keep running */
 297 |     bool toRunDemo;
 298 | 
 299 |     /** Capability state of this client */
 300 |     AiaCapabilitiesSenderState_t capState;
 301 | };
 302 | 
 303 | AiaSampleApp_t *AiaSampleApp_Create( AiaMqttConnectionPointer_t mqttConnection, const char *iotClientId )
 304 | {
 305 |     /* Enabled mbed TLS threading layer. */
 306 |     AiaMbedtlsThreading_Init();
 307 | 
 308 |     /**
 309 |      * Initialize mbed TLS contexts needed for random number generation.
 310 |      * Required if AiaRandom_Rand() and AiaRandom_Seed() are using the
 311 |      * AiaRandomMbedtls implementation.
 312 |      */
 313 |     AiaRandomMbedtls_Init();
 314 | 
 315 |     /**
 316 |      * Initialize Aia MbedTLS Crypto usage.
 317 |      */
 318 |     if( !AiaCryptoMbedtls_Init() )
 319 |     {
 320 |         AiaLogError( "AiaCryptoMbedtls_Init failed" );
 321 |         AiaRandomMbedtls_Cleanup();
 322 |         AiaMbedtlsThreading_Cleanup();
 323 |         return NULL;
 324 |     }
 325 | 
 326 |     if( !AiaRandom_Seed( iotClientId, strlen( iotClientId ) ) )
 327 |     {
 328 |         AiaCryptoMbedtls_Cleanup();
 329 |         AiaRandomMbedtls_Cleanup();
 330 |         AiaMbedtlsThreading_Cleanup();
 331 |         AiaLogError( "AiaRandom_Seed failed" );
 332 |         return NULL;
 333 |     }
 334 | 
 335 |     /* TODO: ADSER-1690 Simplify cleanup. */
 336 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)AiaCalloc( 1, sizeof( AiaSampleApp_t ) );
 337 |     if( !sampleApp )
 338 |     {
 339 |         AiaLogError( "AiaCalloc failed, bytes=%zu.", sizeof( AiaSampleApp_t ) );
 340 |         AiaCryptoMbedtls_Cleanup();
 341 |         AiaRandomMbedtls_Cleanup();
 342 |         AiaMbedtlsThreading_Cleanup();
 343 |         return NULL;
 344 |     }
 345 | 
 346 |     sampleApp->mqttConnection = mqttConnection;
 347 | 
 348 |     sampleApp->rawMicrophoneBuffer = AiaCalloc( MIC_BUFFER_SIZE_IN_BYTES, 1 );
 349 |     if( !sampleApp->rawMicrophoneBuffer )
 350 |     {
 351 |         AiaLogError( "AiaCalloc failed, bytes=%zu", MIC_BUFFER_SIZE_IN_BYTES );
 352 |         AiaFree( sampleApp );
 353 |         AiaCryptoMbedtls_Cleanup();
 354 |         AiaRandomMbedtls_Cleanup();
 355 |         AiaMbedtlsThreading_Cleanup();
 356 |         return NULL;
 357 |     }
 358 | 
 359 |     sampleApp->microphoneBuffer = AiaDataStreamBuffer_Create( sampleApp->rawMicrophoneBuffer, MIC_BUFFER_SIZE_IN_BYTES,
 360 |                                                               AIA_MICROPHONE_BUFFER_WORD_SIZE, MIC_NUM_READERS );
 361 |     if( !sampleApp->microphoneBuffer )
 362 |     {
 363 |         AiaLogError( "AiaDataStreamBuffer_Create failed" );
 364 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 365 |         AiaFree( sampleApp );
 366 |         AiaCryptoMbedtls_Cleanup();
 367 |         AiaRandomMbedtls_Cleanup();
 368 |         AiaMbedtlsThreading_Cleanup();
 369 |         return NULL;
 370 |     }
 371 | 
 372 |     sampleApp->microphoneBufferReader = AiaDataStreamBuffer_CreateReader(
 373 |         sampleApp->microphoneBuffer, AIA_DATA_STREAM_BUFFER_READER_NONBLOCKING, true );
 374 |     if( !sampleApp->microphoneBufferReader )
 375 |     {
 376 |         AiaLogError( "AiaDataStreamBuffer_CreateReader failed" );
 377 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 378 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 379 |         AiaFree( sampleApp );
 380 |         AiaCryptoMbedtls_Cleanup();
 381 |         AiaRandomMbedtls_Cleanup();
 382 |         AiaMbedtlsThreading_Cleanup();
 383 |         return NULL;
 384 |     }
 385 | 
 386 |     sampleApp->microphoneBufferWriter = AiaDataStreamBuffer_CreateWriter(
 387 |         sampleApp->microphoneBuffer, AIA_DATA_STREAM_BUFFER_WRITER_NONBLOCKABLE, false );
 388 |     if( !sampleApp->microphoneBufferWriter )
 389 |     {
 390 |         AiaLogError( "AiaDataStreamBuffer_CreateWriter failed" );
 391 |         AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 392 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 393 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 394 |         AiaFree( sampleApp );
 395 |         AiaCryptoMbedtls_Cleanup();
 396 |         AiaRandomMbedtls_Cleanup();
 397 |         AiaMbedtlsThreading_Cleanup();
 398 |         return NULL;
 399 |     }
 400 | 
 401 | #ifdef AIA_DEMO_AUDIO_ENABLE
 402 |     sampleApp->portAudioMicrophoneRecorder = AiaPortAudioMicrophoneRecorder_Create( sampleApp->microphoneBufferWriter );
 403 |     if( !sampleApp->portAudioMicrophoneRecorder )
 404 |     {
 405 |         AiaLogError( "AiaPortAudioMicrophoneRecorder_Create failed" );
 406 |         AiaDataStreamWriter_Destroy( sampleApp->microphoneBufferWriter );
 407 |         AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 408 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 409 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 410 |         AiaFree( sampleApp );
 411 |         AiaCryptoMbedtls_Cleanup();
 412 |         AiaRandomMbedtls_Cleanup();
 413 |         AiaMbedtlsThreading_Cleanup();
 414 |         return NULL;
 415 |     }
 416 | 
 417 |     sampleApp->isMicrophoneActive = false;
 418 | 
 419 |     sampleApp->opusDecoder = AiaOpusDecoder_Create();
 420 |     if( !sampleApp->opusDecoder )
 421 |     {
 422 |         AiaLogError( "AiaOpusDecoder_Create failed" );
 423 |         AiaPortAudioMicrophoneRecorder_Destroy( sampleApp->portAudioMicrophoneRecorder );
 424 |         AiaDataStreamWriter_Destroy( sampleApp->microphoneBufferWriter );
 425 |         AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 426 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 427 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 428 |         AiaFree( sampleApp );
 429 |         AiaCryptoMbedtls_Cleanup();
 430 |         AiaRandomMbedtls_Cleanup();
 431 |         AiaMbedtlsThreading_Cleanup();
 432 |         return NULL;
 433 |     }
 434 | 
 435 |     sampleApp->portAudioSpeaker = AiaPortAudioSpeaker_Create( onPortAudioSpeakerReadyAgain, sampleApp );
 436 |     if( !sampleApp->portAudioSpeaker )
 437 |     {
 438 |         AiaLogError( "AiaPortAudioSpeakerPlayer_Create failed" );
 439 |         AiaOpusDecoder_Destroy( sampleApp->opusDecoder );
 440 |         AiaPortAudioMicrophoneRecorder_Destroy( sampleApp->portAudioMicrophoneRecorder );
 441 |         AiaDataStreamWriter_Destroy( sampleApp->microphoneBufferWriter );
 442 |         AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 443 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 444 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 445 |         AiaFree( sampleApp );
 446 |         AiaCryptoMbedtls_Cleanup();
 447 |         AiaRandomMbedtls_Cleanup();
 448 |         AiaMbedtlsThreading_Cleanup();
 449 |         return NULL;
 450 |     }
 451 | #endif
 452 | 
 453 | #ifdef AIA_ENABLE_SPEAKER
 454 |     if( !AiaTimer( Create )( &sampleApp->offlineAlertPlaybackTimer,
 455 |                              onPlayOfflineAlertTone, sampleApp ) )
 456 |     {
 457 |         AiaLogError( "AiaTimer( Create ) failed" );
 458 | #ifdef AIA_DEMO_AUDIO_ENABLE
 459 |         AiaPortAudioSpeaker_Destroy( sampleApp->portAudioSpeaker );
 460 |         AiaOpusDecoder_Destroy( sampleApp->opusDecoder );
 461 |         AiaPortAudioMicrophoneRecorder_Destroy( sampleApp->portAudioMicrophoneRecorder );
 462 | #endif
 463 |         AiaDataStreamWriter_Destroy( sampleApp->microphoneBufferWriter );
 464 |         AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 465 |         AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 466 |         AiaFree( sampleApp->rawMicrophoneBuffer );
 467 |         AiaFree( sampleApp );
 468 |         AiaCryptoMbedtls_Cleanup();
 469 |         AiaRandomMbedtls_Cleanup();
 470 |         AiaMbedtlsThreading_Cleanup();
 471 |         return NULL;
 472 |     }
 473 | #endif
 474 | 
 475 |     AiaAtomicBool_Clear( &sampleApp->shouldPublishEvent );
 476 | 
 477 | #ifdef AIA_ENABLE_SPEAKER
 478 |     AiaAtomicBool_Set( &sampleApp->isSpeakerReady );
 479 |     AiaAtomicBool_Clear( &sampleApp->shouldDeleteOfflineAlert );
 480 | #endif
 481 | 
 482 |     g_aiaIotEndpoint = clientcredentialMQTT_BROKER_ENDPOINT;
 483 |     g_aiaClientId = clientcredentialIOT_THING_NAME;
 484 |     g_aiaAwsAccountId = AIA_REG_HTTPS_AWS_ACCOUNT_ID;
 485 |     g_aiaLwaRefreshToken = AIA_REG_HTTPS_LWA_REFRESH_TOKEN;
 486 |     g_aiaLwaClientId = AIA_REG_HTTPS_LWA_CLIENT_ID;
 487 | 
 488 |     aia_eg = xEventGroupCreate();
 489 |     sampleApp->isAiaClientConnected = false;
 490 |     sampleApp->toRunDemo = true;
 491 |     sampleApp->capState = AIA_CAPABILITIES_STATE_NONE;
 492 | 
 493 |     return sampleApp;
 494 | }
 495 | 
 496 | void AiaSampleApp_Destroy( AiaSampleApp_t *sampleApp )
 497 | {
 498 |     AiaAssert( sampleApp );
 499 |     if( !sampleApp )
 500 |     {
 501 |         AiaLogError( "Null sampleApp" );
 502 |         return;
 503 |     }
 504 | 
 505 |     AiaAtomicBool_Clear( &sampleApp->shouldPublishEvent );
 506 | 
 507 | #ifdef AIA_ENABLE_SPEAKER
 508 |     AiaAtomicBool_Clear( &sampleApp->isSpeakerReady );
 509 |     AiaAtomicBool_Clear( &sampleApp->shouldDeleteOfflineAlert );
 510 | 
 511 |     AiaTimer( Destroy )( &sampleApp->offlineAlertPlaybackTimer );
 512 |     if( sampleApp->offlineAlertInProgress )
 513 |     {
 514 |         AiaFree( sampleApp->offlineAlertInProgress );
 515 |         sampleApp->offlineAlertInProgress = NULL;
 516 |     }
 517 | #endif
 518 | 
 519 | #ifdef AIA_DEMO_AUDIO_ENABLE
 520 |     AiaPortAudioSpeaker_Destroy( sampleApp->portAudioSpeaker );
 521 |     AiaOpusDecoder_Destroy( sampleApp->opusDecoder );
 522 |     AiaPortAudioMicrophoneRecorder_Destroy( sampleApp->portAudioMicrophoneRecorder );
 523 | #endif
 524 |     if( sampleApp->aiaClient )
 525 |     {
 526 |         AiaClient_Destroy( sampleApp->aiaClient );
 527 |         sampleApp->aiaClient = NULL;
 528 |     }
 529 | 
 530 |     AiaDataStreamWriter_Destroy( sampleApp->microphoneBufferWriter );
 531 |     AiaDataStreamReader_Destroy( sampleApp->microphoneBufferReader );
 532 |     AiaDataStreamBuffer_Destroy( sampleApp->microphoneBuffer );
 533 |     AiaFree( sampleApp->rawMicrophoneBuffer );
 534 |     sampleApp->isAiaClientConnected = false;
 535 |     sampleApp->toRunDemo = false;
 536 |     sampleApp->capState = AIA_CAPABILITIES_STATE_NONE;
 537 |     AiaFree( sampleApp );
 538 | 
 539 |     AiaCryptoMbedtls_Cleanup();
 540 |     AiaRandomMbedtls_Cleanup();
 541 |     AiaMbedtlsThreading_Cleanup();
 542 | 
 543 |     vEventGroupDelete( aia_eg );
 544 | }
 545 | 
 546 | void AiaSampleApp_Run( AiaSampleApp_t *sampleApp )
 547 | {
 548 |     AiaAssert( sampleApp );
 549 |     if( !sampleApp )
 550 |     {
 551 |         AiaLogError( "Null sampleApp" );
 552 |         return;
 553 |     }
 554 | 
 555 | #ifdef AIA_DEMO_AUDIO_ENABLE
 556 |     const AIA_DEMO_CASES_E cmd[] = { AIA_DEMO_CASE_CONNECT,           AIA_DEMO_CASE_CAPABILITY,
 557 |                                      AIA_DEMO_CASE_SYNC_ST,           AIA_DEMO_CASE_HOLD_TO_TALK_START,
 558 |                                      AIA_DEMO_CASE_HOLD_TO_TALK_STOP, AIA_DEMO_CASE_DISCONNECT };
 559 | #else
 560 |     const AIA_DEMO_CASES_E cmd[] = { AIA_DEMO_CASE_CONNECT, AIA_DEMO_CASE_CAPABILITY, AIA_DEMO_CASE_SYNC_ST,
 561 |                                      AIA_DEMO_CASE_SYNC_TIME, AIA_DEMO_CASE_DISCONNECT };
 562 | #endif
 563 | 
 564 |     if( !registerAia( sampleApp ) )
 565 |     {
 566 |         AiaLogError( "Registration Failed" );
 567 |         sampleApp->toRunDemo = false;
 568 |         return;
 569 |     }
 570 |     AiaLogInfo( "Aia Registered." );
 571 | 
 572 |     if( !initAiaClient( sampleApp ) )
 573 |     {
 574 |         AiaLogError( "Client initialization failed" );
 575 |         sampleApp->toRunDemo = false;
 576 |         return;
 577 |     }
 578 |     AiaLogInfo( "Client initialized." );
 579 | 
 580 |     for( int i = 0; i < sizeof( cmd ) / sizeof( AIA_DEMO_CASES_E ) && sampleApp->toRunDemo; ++i )
 581 |     {
 582 |         AIA_DEMO_CASES_E command = cmd[ i ];
 583 |         AiaLogInfo( "---- Current demo case = %s ----", AIA_DEMO_CASE_TO_STRING[ command ] );
 584 |         processDemoCase( command, sampleApp );
 585 |     }
 586 | 
 587 |     if( sampleApp->aiaClient )
 588 |     {
 589 |         if( sampleApp->isAiaClientConnected )
 590 |         {
 591 |             AiaClient_Disconnect( sampleApp->aiaClient, AIA_CONNECTION_ON_DISCONNECTED_GOING_OFFLINE, NULL );
 592 |             AIA_DEMO_EG_WAIT( AIA_EVENT_DISCONNECTED, 5000 );
 593 |             if( 0 == ( AIA_DEMO_EG_GET() & AIA_EVENT_DISCONNECTED ) )
 594 |             {
 595 |                 AiaLogError( "Client disconnect timeout." );
 596 |             }
 597 |         }
 598 |         AiaClient_Destroy( sampleApp->aiaClient );
 599 |         sampleApp->aiaClient = NULL;
 600 |         sampleApp->toRunDemo = false;
 601 |         AiaLogInfo( "Client deinitialize." );
 602 |     }
 603 | }
 604 | 
 605 | static bool initAiaClient( AiaSampleApp_t *sampleApp )
 606 | {
 607 |     AiaLogInfo( "Initializing client." );
 608 |     sampleApp->aiaClient =
 609 |         AiaClient_Create( sampleApp->mqttConnection, onAiaConnectionSuccessfulSimpleUI, onAiaConnectionRejectedSimpleUI,
 610 |                           onAiaDisconnectedSimpleUI, sampleApp, AiaTaskPool( GetSystemTaskPool )(),
 611 |                           onAiaExceptionReceivedSimpleUI, NULL, onAiaCapabilitiesStateChangedSimpleUI, sampleApp
 612 | #ifdef AIA_ENABLE_SPEAKER
 613 |                           ,
 614 |                           onSpeakerFramePushedForPlayback, sampleApp, onSpeakerVolumeChanged, sampleApp, onStartOfflineAlertTone, sampleApp, onStopOfflineAlertTone, sampleApp
 615 | #endif
 616 |                           ,
 617 |                           onUXStateChangedSimpleUI, NULL
 618 | #ifdef AIA_ENABLE_MICROPHONE
 619 |                           ,
 620 |                           sampleApp->microphoneBufferReader
 621 | #endif
 622 |         );
 623 | 
 624 |     if( !sampleApp->aiaClient )
 625 |     {
 626 |         AiaLogError( "AiaClient_Create failed" );
 627 |         return false;
 628 |     }
 629 | 
 630 |     return true;
 631 | }
 632 | 
 633 | static bool registerAia( AiaSampleApp_t *sampleApp )
 634 | {
 635 |     AiaLogInfo( "Registering with Aia" );
 636 |     sampleApp->registrationManager =
 637 |         AiaRegistrationManager_Create( onAiaRegistrationSuccess, sampleApp, onAiaRegistrationFailed, sampleApp );
 638 |     if( !sampleApp->registrationManager )
 639 |     {
 640 |         AiaLogError( "AiaRegistrationManager_Create failed" );
 641 |         return false;
 642 |     }
 643 | 
 644 |     if( !AiaRegistrationManager_Register( sampleApp->registrationManager ) )
 645 |     {
 646 |         AiaLogError( "AiaRegistrationManager_Register Failed" );
 647 |         AiaRegistrationManager_Destroy( sampleApp->registrationManager );
 648 |         sampleApp->registrationManager = NULL;
 649 |         return false;
 650 |     }
 651 |     return true;
 652 | }
 653 | 
 654 | static void onAiaRegistrationSuccess( void *userData )
 655 | {
 656 |     if( !userData )
 657 |     {
 658 |         AiaLogError( "Null userData." );
 659 |         return;
 660 |     }
 661 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 662 |     AiaLogInfo( "Registration Succeeded" );
 663 |     AiaRegistrationManager_Destroy( sampleApp->registrationManager );
 664 |     sampleApp->registrationManager = NULL;
 665 | }
 666 | 
 667 | static void onAiaRegistrationFailed( void *userData, AiaRegistrationFailureCode_t code )
 668 | {
 669 |     if( !userData )
 670 |     {
 671 |         AiaLogError( "Null userData." );
 672 |         return;
 673 |     }
 674 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 675 |     AiaLogInfo( "Registration Failed, code=%d", code );
 676 |     AiaRegistrationManager_Destroy( sampleApp->registrationManager );
 677 |     sampleApp->registrationManager = NULL;
 678 | }
 679 | 
 680 | void processDemoCase( AIA_DEMO_CASES_E c, AiaSampleApp_t *sampleApp )
 681 | {
 682 |     switch( c )
 683 |     {
 684 |         case AIA_DEMO_CASE_CONNECT:
 685 |             AiaLogInfo( "Connecting to Aia" );
 686 |             if( !AiaClient_Connect( sampleApp->aiaClient ) )
 687 |             {
 688 |                 AiaLogError( "Failed to connect to Aia" );
 689 |                 sampleApp->toRunDemo = false;
 690 |                 return;
 691 |             }
 692 |             AIA_DEMO_EG_WAIT( AIA_EVENT_CONNECTED, 5000 );
 693 |             sampleApp->toRunDemo = sampleApp->isAiaClientConnected;
 694 |             return;
 695 |         case AIA_DEMO_CASE_DISCONNECT:
 696 |             AiaLogInfo( "Disconnecting from Aia" );
 697 |             if( !AiaClient_Disconnect( sampleApp->aiaClient, AIA_CONNECTION_ON_DISCONNECTED_GOING_OFFLINE, NULL ) )
 698 |             {
 699 |                 AiaLogError( "Failed to disconnect from Aia" );
 700 |             }
 701 |             AIA_DEMO_EG_WAIT( AIA_EVENT_DISCONNECTED, 5000 );
 702 |             return;
 703 | #ifdef AIA_DEMO_AUDIO_ENABLE
 704 |         case AIA_DEMO_CASE_HOLD_TO_TALK_START:
 705 |             AiaLogInfo( "Hold to talk" );
 706 |             if( !sampleApp->isMicrophoneOpen )
 707 |             {
 708 |                 sampleApp->isMicrophoneOpen = !sampleApp->isMicrophoneOpen;
 709 | #ifdef AIA_ENABLE_SPEAKER
 710 |                 AiaClient_StopSpeaker( sampleApp->aiaClient );
 711 |                 AiaLogInfo( "\n\n-------- Start to talk --------\n\n" );
 712 |                 AIA_DEMO_EG_DUMMY_WAIT_WAIT( 500 );
 713 |                 if( 0 == ( AIA_DEMO_EG_GET() & AIA_EVENT_DISCONNECTED ) )
 714 |                 {
 715 |                     if( !AiaClient_HoldToTalkStart( sampleApp->aiaClient, AiaDataStreamWriter_Tell( sampleApp->microphoneBufferWriter ) ) )
 716 |                     {
 717 |                         AiaLogError( "\n\n-------- Failed to initiate hold-to-talk. --------\n\n" );
 718 |                         sampleApp->toRunDemo = false;
 719 |                         return;
 720 |                     }
 721 |                     if( !sampleApp->isMicrophoneActive )
 722 |                     {
 723 |                         AiaPortAudioMicrophoneRecorder_StartStreamingMicrophoneData( sampleApp->portAudioMicrophoneRecorder );
 724 |                         sampleApp->isMicrophoneActive = true;
 725 |                         AiaLogInfo( "New microphone state: %s", sampleApp->isMicrophoneActive ? "on" : "off" );
 726 |                     }
 727 |                     AIA_DEMO_EG_DUMMY_WAIT_WAIT( 2500 );
 728 |                 }
 729 | #endif
 730 |             }
 731 |             return;
 732 |         case AIA_DEMO_CASE_HOLD_TO_TALK_STOP:
 733 |             if( sampleApp->isMicrophoneOpen )
 734 |             {
 735 |                 if( sampleApp->isMicrophoneActive )
 736 |                 {
 737 |                     AiaPortAudioMicrophoneRecorder_StopStreamingMicrophoneData(
 738 |                         sampleApp->portAudioMicrophoneRecorder );
 739 |                     sampleApp->isMicrophoneActive = false;
 740 |                     AiaLogInfo( "New microphone state: %s", sampleApp->isMicrophoneActive ? "on" : "off" );
 741 |                 }
 742 |                 AiaLogInfo( "\n\n-------- Stop talking --------\n\n" );
 743 |                 AIA_DEMO_EG_DUMMY_WAIT_WAIT( 2500 );
 744 |                 AiaClient_CloseMicrophone( sampleApp->aiaClient );
 745 |                 if( 0 == ( AIA_DEMO_EG_GET() & AIA_EVENT_DISCONNECTED ) )
 746 |                 {
 747 |                     AiaLogInfo( "\n\n-------- Waiting for hold-to-talk AIS response... --------\n\n" );
 748 |                     AIA_DEMO_EG_DUMMY_WAIT_WAIT( 7000 );
 749 |                     sampleApp->isMicrophoneOpen = !sampleApp->isMicrophoneOpen;
 750 |                     AiaClient_StopSpeaker( sampleApp->aiaClient );
 751 |                 }
 752 |                 else
 753 |                 {
 754 |                     AiaLogWarn( "\n\n-------- Skip hold-to-talk demo because of disconnection. --------\n\n" );
 755 |                     return;
 756 |                 }
 757 |             }
 758 |             return;
 759 | #endif
 760 |         case AIA_DEMO_CASE_CAPABILITY:
 761 |             AiaLogInfo( "Publishing capabilities" );
 762 |             if( !AiaClient_PublishCapabilities( sampleApp->aiaClient ) )
 763 |             {
 764 |                 AiaLogError( "Failed to publish capabilities." );
 765 |                 sampleApp->toRunDemo = false;
 766 |                 return;
 767 |             }
 768 |             AIA_DEMO_EG_WAIT( AIA_EVENT_CAP_CHANGED, 5000 );
 769 |             sampleApp->toRunDemo = sampleApp->capState == AIA_CAPABILITIES_STATE_PUBLISHED;
 770 |             if( sampleApp->toRunDemo )
 771 |             {
 772 |                 AIA_DEMO_EG_WAIT( AIA_EVENT_CAP_CHANGED, 5000 );
 773 |                 sampleApp->toRunDemo = sampleApp->capState == AIA_CAPABILITIES_STATE_ACCEPTED;
 774 |             }
 775 |             return;
 776 |         case AIA_DEMO_CASE_SYNC_ST:
 777 |             AiaLogInfo( "Publishing SynchronizeState event" );
 778 |             if( !AiaClient_SynchronizeState( sampleApp->aiaClient ) )
 779 |             {
 780 |                 AiaLogError( "Failed to synchronize state." );
 781 |                 sampleApp->toRunDemo = false;
 782 |                 return;
 783 |             }
 784 |             return;
 785 | #ifdef AIA_ENABLE_CLOCK
 786 |         case AIA_DEMO_CASE_SYNC_TIME:
 787 |             AiaLogInfo( "Initiating NTP clock synchronization" );
 788 |             if( !AiaClient_SynchronizeClock( sampleApp->aiaClient ) )
 789 |             {
 790 |                 AiaLogError( "Failed to synchronize clock." );
 791 |                 sampleApp->toRunDemo = false;
 792 |                 return;
 793 |             }
 794 |             return;
 795 | #endif
 796 |         default:
 797 |             AiaLogInfo( "Unsupported test case" );
 798 |             sampleApp->toRunDemo = false;
 799 |             return;
 800 |     }
 801 | }
 802 | 
 803 | static void onAiaConnectionSuccessfulSimpleUI( void *userData )
 804 | {
 805 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 806 |     AiaAssert( sampleApp );
 807 |     if( !sampleApp )
 808 |     {
 809 |         AiaLogError( "Null sampleApp" );
 810 |         return;
 811 |     }
 812 |     AiaAtomicBool_Set( &sampleApp->shouldPublishEvent );
 813 |     AiaLogInfo( "Aia connection successful" );
 814 | 
 815 |     sampleApp->isAiaClientConnected = true;
 816 |     AIA_DEMO_EG_SET( AIA_EVENT_CONNECTED );
 817 | }
 818 | 
 819 | static void onAiaDisconnectedSimpleUI( void *userData, AiaConnectionOnDisconnectCode_t code )
 820 | {
 821 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 822 |     AiaAssert( sampleApp );
 823 |     if( !sampleApp )
 824 |     {
 825 |         AiaLogError( "Null sampleApp" );
 826 |         return;
 827 |     }
 828 |     AiaAtomicBool_Clear( &sampleApp->shouldPublishEvent );
 829 |     AiaLogWarn( "Disconnected from Aia, code=%d", code );
 830 | 
 831 |     sampleApp->isAiaClientConnected = false;
 832 |     sampleApp->toRunDemo = false;
 833 |     AiaLogWarn( "Stop demo because client is disconnected now" );
 834 |     AIA_DEMO_EG_SET( AIA_EVENT_DISCONNECTED );
 835 | }
 836 | 
 837 | static void onAiaConnectionRejectedSimpleUI( void *userData, AiaConnectionOnConnectionRejectionCode_t code )
 838 | {
 839 |     AiaSampleApp_t* sampleApp = (AiaSampleApp_t*)userData;
 840 |     AiaAssert( sampleApp );
 841 |     if( !sampleApp )
 842 |     {
 843 |         AiaLogError( "Null sampleApp" );
 844 |         return;
 845 |     }
 846 | 
 847 |     AiaAtomicBool_Clear( &sampleApp->shouldPublishEvent );
 848 |     AiaLogInfo( "Aia connection rejected, code=%d", code );
 849 | }
 850 | 
 851 | static void onAiaExceptionReceivedSimpleUI( void *userData, AiaExceptionCode_t code )
 852 | {
 853 |     (void)userData;
 854 |     AiaLogInfo( "Aia exception received, code=%d", code );
 855 | }
 856 | 
 857 | static void onAiaCapabilitiesStateChangedSimpleUI( AiaCapabilitiesSenderState_t state, const char *description,
 858 |                                                    size_t descriptionLen, void *userData )
 859 | {
 860 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 861 |     AiaLogInfo( "Aia capabilities state changed, state=%s, description=%.*s",
 862 |                 AiaCapabilitiesSenderState_ToString( state ), descriptionLen, description );
 863 |     sampleApp->capState = state;
 864 |     AIA_DEMO_EG_SET( AIA_EVENT_CAP_CHANGED );
 865 | }
 866 | 
 867 | static void onPortAudioSpeakerReadyAgain( void *userData )
 868 | {
 869 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 870 |     AiaAssert( sampleApp );
 871 |     if( !sampleApp )
 872 |     {
 873 |         AiaLogError( "Null sampleApp" );
 874 |         return;
 875 |     }
 876 |     AiaAtomicBool_Set( &sampleApp->isSpeakerReady );
 877 | #ifdef AIA_ENABLE_SPEAKER
 878 |     AiaClient_OnSpeakerReady( sampleApp->aiaClient );
 879 | #endif
 880 | }
 881 | 
 882 | #ifdef AIA_ENABLE_SPEAKER
 883 | static bool onSpeakerFramePushedForPlayback( const void *buf, size_t size, void *userData )
 884 | {
 885 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 886 |     AiaAssert( sampleApp );
 887 |     if( !sampleApp )
 888 |     {
 889 |         AiaLogError( "Null sampleApp" );
 890 |         return false;
 891 |     }
 892 |     AiaLogDebug( "Received speaker frame for playback, size=%zu", size );
 893 | 
 894 |     bool ret = true;
 895 |     int16_t *pcmSamples = NULL;
 896 | #ifdef AIA_DEMO_AUDIO_ENABLE
 897 |     int decodedSamples = 0;
 898 |     pcmSamples = AiaOpusDecoder_DecodeFrame( sampleApp->opusDecoder, buf, size, &decodedSamples );
 899 |     if( !pcmSamples )
 900 |     {
 901 |         AiaLogError( "AiaOpusDecoder_DecodeFrame failed" );
 902 |         return false;
 903 |     }
 904 | 
 905 |     ret = AiaPortAudioSpeaker_PlaySpeakerData( sampleApp->portAudioSpeaker, pcmSamples, decodedSamples );
 906 | #endif
 907 |     if( pcmSamples )
 908 |     {
 909 |         AiaFree( pcmSamples );
 910 |     }
 911 |     return ret;
 912 | }
 913 | 
 914 | static void onSpeakerVolumeChanged( uint8_t newVolume, void *userData )
 915 | {
 916 |     AiaSampleApp_t *sampleApp = (AiaSampleApp_t *)userData;
 917 |     AiaAssert( sampleApp );
 918 |     if( !sampleApp )
 919 |     {
 920 |         AiaLogError( "Null sampleApp" );
 921 |         return;
 922 |     }
 923 |     AiaLogDebug( "Received volume change, volume=%" PRIu8, newVolume );
 924 | #ifdef AIA_DEMO_AUDIO_ENABLE
 925 |     if( sampleApp->portAudioSpeaker )
 926 |     {
 927 |         AiaPortAudioSpeaker_SetNewVolume( sampleApp->portAudioSpeaker, newVolume );
 928 |     }
 929 | #endif
 930 | }
 931 | 
 932 | static bool onStopOfflineAlertTone( void* userData )
 933 | {
 934 |     AiaSampleApp_t* sampleApp = (AiaSampleApp_t*)userData;
 935 |     AiaAssert( sampleApp );
 936 |     if( !sampleApp )
 937 |     {
 938 |         AiaLogError( "Null sampleApp" );
 939 |         return false;
 940 |     }
 941 | 
 942 |     /* Destroy offline alert playback timer */
 943 |     AiaTimer( Destroy )( &sampleApp->offlineAlertPlaybackTimer );
 944 |     if( !AiaTimer( Create )( &sampleApp->offlineAlertPlaybackTimer,
 945 |                              onPlayOfflineAlertTone, sampleApp ) )
 946 |     {
 947 |         AiaLogError( "AiaTimer( Create ) failed" );
 948 |         return false;
 949 |     }
 950 | 
 951 |     /* Clear offline alert in progress, clear conditional flags */
 952 |     if( sampleApp->offlineAlertInProgress )
 953 |     {
 954 |         AiaFree( sampleApp->offlineAlertInProgress );
 955 |         sampleApp->offlineAlertInProgress = NULL;
 956 |     }
 957 |     sampleApp->offlineAlertPlaybackStartTime = 0;
 958 |     AiaAtomicBool_Clear( &sampleApp->shouldDeleteOfflineAlert );
 959 | 
 960 |     return true;
 961 | }
 962 | 
 963 | static bool onStartOfflineAlertTone( const AiaAlertSlot_t* offlineAlert,
 964 |                                      void* userData )
 965 | {
 966 |     AiaSampleApp_t* sampleApp = (AiaSampleApp_t*)userData;
 967 |     AiaAssert( sampleApp );
 968 |     if( !sampleApp )
 969 |     {
 970 |         AiaLogError( "Null sampleApp" );
 971 |         return false;
 972 |     }
 973 |     if( !offlineAlert )
 974 |     {
 975 |         AiaLogError( "Null offlineAlert" );
 976 |         return false;
 977 |     }
 978 | 
 979 |     /* Set the offline alert to play, initialize conditional variables */
 980 |     sampleApp->offlineAlertInProgress =
 981 |         AiaCalloc( 1, sizeof( AiaAlertSlot_t ) );
 982 |     if( !sampleApp->offlineAlertInProgress )
 983 |     {
 984 |         AiaLogError( "AiaCalloc failed, bytes=%zu.", sizeof( AiaAlertSlot_t ) );
 985 |         return false;
 986 |     }
 987 |     *sampleApp->offlineAlertInProgress = *offlineAlert;
 988 | 
 989 |     /* Set the time we started offline alert playback */
 990 |     sampleApp->offlineAlertPlaybackStartTime = AiaClock_GetTimeSinceNTPEpoch();
 991 | 
 992 |     AiaLogDebug( "Playing offline alert tone for %s",
 993 |                  AiaAlertType_ToString( offlineAlert->alertType ) );
 994 | 
 995 |     /* Arm the offline alert playback timer to go off every @c
 996 |      * AIA_SPEAKER_FRAME_PUSH_CADENCE_MS milliseconds */
 997 |     if( !AiaTimer( Arm )( &sampleApp->offlineAlertPlaybackTimer, 0,
 998 |                           AIA_SPEAKER_FRAME_PUSH_CADENCE_MS ) )
 999 |     {
1000 |         AiaLogError( "AiaTimer( Arm ) failed" );
1001 |         if( sampleApp->offlineAlertInProgress )
1002 |         {
1003 |             AiaFree( sampleApp->offlineAlertInProgress );
1004 |             sampleApp->offlineAlertInProgress = NULL;
1005 |         }
1006 |         sampleApp->offlineAlertPlaybackStartTime = 0;
1007 |         AiaTimer( Destroy )( &sampleApp->offlineAlertPlaybackTimer );
1008 |         return false;
1009 |     }
1010 | 
1011 |     AiaLogInfo( "Started offline alert playback timer" );
1012 | 
1013 |     return true;
1014 | }
1015 | 
1016 | static void onPlayOfflineAlertTone( void* userData )
1017 | {
1018 |     AiaSampleApp_t* sampleApp = (AiaSampleApp_t*)userData;
1019 |     AiaAssert( sampleApp );
1020 |     if( !sampleApp )
1021 |     {
1022 |         AiaLogError( "Null sampleApp" );
1023 |         return;
1024 |     }
1025 | 
1026 |     /* Quit early if speaker is not ready or if offline alert playback is
1027 |      * disabled */
1028 |     if( !AiaAtomicBool_Load( &sampleApp->isSpeakerReady ) )
1029 |     {
1030 |         return;
1031 |     }
1032 | 
1033 |     /* Pointer to the offline alert that should be played */
1034 |     AiaAlertSlot_t* offlineAlert = sampleApp->offlineAlertInProgress;
1035 | 
1036 |     /* Check if this alert exceeded its duration */
1037 |     AiaTimepointSeconds_t now = AiaClock_GetTimeSinceNTPEpoch();
1038 |     if( now >= offlineAlert->scheduledTime )
1039 |     {
1040 |         AiaDurationSeconds_t timeSinceAlertStart =
1041 |             now - offlineAlert->scheduledTime;
1042 |         if( timeSinceAlertStart * AIA_MS_PER_SECOND > offlineAlert->duration )
1043 |         {
1044 |             AiaLogDebug( "Offline alert expired, deleting it" );
1045 |             AiaAtomicBool_Set( &sampleApp->shouldDeleteOfflineAlert );
1046 |         }
1047 |     }
1048 | 
1049 |     /* Invoke the callback to delete the alert from local storage if it is
1050 |      * supposed to be deleted */
1051 |     if( AiaAtomicBool_Load( &sampleApp->shouldDeleteOfflineAlert ) )
1052 |     {
1053 |         if( !AiaClient_DeleteAlert( sampleApp->aiaClient,
1054 |                                     offlineAlert->alertToken ) )
1055 |         {
1056 |             AiaLogWarn( "Failed to delete offline alert" );
1057 |         }
1058 | 
1059 |         AiaTimer( Destroy )( &sampleApp->offlineAlertPlaybackTimer );
1060 |         if( !AiaTimer( Create )( &sampleApp->offlineAlertPlaybackTimer,
1061 |                                  onPlayOfflineAlertTone, sampleApp ) )
1062 |         {
1063 |             AiaLogError( "AiaTimer( Create ) failed" );
1064 |         }
1065 | 
1066 |         if( sampleApp->offlineAlertInProgress )
1067 |         {
1068 |             AiaFree( sampleApp->offlineAlertInProgress );
1069 |             sampleApp->offlineAlertInProgress = NULL;
1070 |         }
1071 |         sampleApp->offlineAlertPlaybackStartTime = 0;
1072 |         AiaAtomicBool_Clear( &sampleApp->shouldDeleteOfflineAlert );
1073 | 
1074 |         return;
1075 |     }
1076 | 
1077 |     /* Variables needed to play the offline alert tone */
1078 |     size_t numFrames = 0;
1079 |     size_t frameLength = 0;
1080 | 
1081 |     /* Check for correct alert type */
1082 |     switch( offlineAlert->alertType )
1083 |     {
1084 |         case AIA_ALERT_TYPE_ALARM:
1085 |         case AIA_ALERT_TYPE_REMINDER:
1086 |         case AIA_ALERT_TYPE_TIMER:
1087 | #ifdef AIA_DEMO_AUDIO_ENABLE
1088 |             numFrames = AIA_SPEAKER_FRAME_PUSH_CADENCE_MS /
1089 |                         AIA_ALERT_TONE_FRAME_LENGTH_IN_MS;
1090 |             /* Make sure we are pushing at least one frame */
1091 |             numFrames = numFrames > 0 ? numFrames : 1;
1092 |             frameLength = AIA_ALERT_TONE_FRAME_LENGTH;
1093 | #endif
1094 |             break;
1095 |         default:
1096 |             AiaLogError( "Unknown alert type:%" PRIu32,
1097 |                          offlineAlert->alertType );
1098 |             if( sampleApp->offlineAlertInProgress )
1099 |             {
1100 |                 AiaFree( sampleApp->offlineAlertInProgress );
1101 |                 sampleApp->offlineAlertInProgress = NULL;
1102 |             }
1103 |             sampleApp->offlineAlertPlaybackStartTime = 0;
1104 |             return;
1105 |     }
1106 | 
1107 |     for( size_t i = 0; i < numFrames; ++i )
1108 |     {
1109 | #ifdef AIA_DEMO_AUDIO_ENABLE
1110 |         if( !AiaPortAudioSpeaker_PlaySpeakerData(
1111 |                 sampleApp->portAudioSpeaker, AIA_ALERT_TONE, frameLength ) )
1112 |         {
1113 |             AiaLogDebug( "Failed to play offline alert buffer" );
1114 |             AiaAtomicBool_Clear( &sampleApp->isSpeakerReady );
1115 |             return;
1116 |         }
1117 | #endif
1118 |     }
1119 | 
1120 |     return;
1121 | }
1122 | #endif
1123 | 
1124 | static void onUXStateChangedSimpleUI( AiaUXState_t state, void *userData )
1125 | {
1126 |     (void)userData;
1127 |     AiaLogInfo( "**** UX state changed, state=%s ****", AiaUXState_ToString( state ) );
1128 | }
1129 | 


--------------------------------------------------------------------------------