STATUS initApp()

in source/src/AppCommon.c [721:820]

• 79 lines of code
• 6 McCabe index (conditional complexity)

STATUS initApp(BOOL trickleIce, BOOL useTurn, PAppConfiguration* ppAppConfiguration)
{
    STATUS retStatus = STATUS_SUCCESS;
    PAppConfiguration pAppConfiguration = NULL;
    PAppSignaling pAppSignaling = NULL;
    PCHAR pChannel = NULL;

    SET_LOGGER_LOG_LEVEL(getLogLevel());
    signal(SIGINT, sigIntHandler);

    CHK(ppAppConfiguration != NULL, STATUS_APP_COMMON_NULL_ARG);
    CHK((pChannel = GETENV(APP_WEBRTC_CHANNEL)) != NULL, STATUS_APP_COMMON_CHANNEL_NAME);
    CHK(NULL != (pAppConfiguration = (PAppConfiguration) MEMCALLOC(1, SIZEOF(AppConfiguration))), STATUS_APP_COMMON_NOT_ENOUGH_MEMORY);

    pAppSignaling = &pAppConfiguration->appSignaling;
    pAppSignaling->signalingClientHandle = INVALID_SIGNALING_CLIENT_HANDLE_VALUE;
    pAppConfiguration->mediaSenderTid = INVALID_TID_VALUE;
    pAppConfiguration->timerQueueHandle = INVALID_TIMER_QUEUE_HANDLE_VALUE;
    pAppConfiguration->iceCandidatePairStatsTimerId = MAX_UINT32;
    pAppConfiguration->pregenerateCertTimerId = MAX_UINT32;

    DLOGD("initializing the app with channel(%s)", pChannel);

    setupFileLogging(&pAppConfiguration->enableFileLogging);
    CHK_STATUS((createCredential(&pAppConfiguration->appCredential)));

    pAppConfiguration->appConfigurationObjLock = MUTEX_CREATE(TRUE);
    CHK(IS_VALID_MUTEX_VALUE(pAppConfiguration->appConfigurationObjLock), STATUS_APP_COMMON_INVALID_MUTEX);
    pAppConfiguration->cvar = CVAR_CREATE();
    pAppConfiguration->streamingSessionListReadLock = MUTEX_CREATE(FALSE);
    CHK(IS_VALID_MUTEX_VALUE(pAppConfiguration->streamingSessionListReadLock), STATUS_APP_COMMON_INVALID_MUTEX);
    CHK(appTimerQueueCreate(&pAppConfiguration->timerQueueHandle) == STATUS_SUCCESS, STATUS_APP_COMMON_TIMER);

    pAppConfiguration->trickleIce = trickleIce;
    pAppSignaling->pAppCredential = &pAppConfiguration->appCredential;
    pAppSignaling->channelInfo.pRegion = GETENV(DEFAULT_REGION_ENV_VAR) == NULL ? DEFAULT_AWS_REGION : GETENV(DEFAULT_REGION_ENV_VAR);
    pAppSignaling->channelInfo.version = CHANNEL_INFO_CURRENT_VERSION;
    pAppSignaling->channelInfo.pChannelName = pChannel;
    pAppSignaling->channelInfo.pKmsKeyId = NULL;
    pAppSignaling->channelInfo.tagCount = 0;
    pAppSignaling->channelInfo.pTags = NULL;
    pAppSignaling->channelInfo.channelType = SIGNALING_CHANNEL_TYPE_SINGLE_MASTER;
    pAppSignaling->channelInfo.channelRoleType = SIGNALING_CHANNEL_ROLE_TYPE_MASTER;
    pAppSignaling->channelInfo.cachingPolicy = SIGNALING_API_CALL_CACHE_TYPE_FILE;
    pAppSignaling->channelInfo.cachingPeriod = SIGNALING_API_CALL_CACHE_TTL_SENTINEL_VALUE;
    pAppSignaling->channelInfo.asyncIceServerConfig = TRUE;
    pAppSignaling->channelInfo.retry = TRUE;
    pAppSignaling->channelInfo.reconnect = TRUE;
    pAppSignaling->channelInfo.pCertPath = pAppConfiguration->appCredential.pCaCertPath;
    pAppSignaling->channelInfo.messageTtl = 0; // Default is 60 seconds

    pAppSignaling->clientInfo.version = SIGNALING_CLIENT_INFO_CURRENT_VERSION;
    pAppSignaling->clientInfo.loggingLevel = getLogLevel();
    pAppSignaling->clientInfo.cacheFilePath = NULL; // Use the default path
    STRCPY(pAppSignaling->clientInfo.clientId, APP_MASTER_CLIENT_ID);

    CHK_STATUS((initAppSignaling(pAppSignaling, onSignalingMessageReceived, onSignalingClientStateChanged, onSignalingClientError,
                                 (UINT64) pAppConfiguration, useTurn)));

    ATOMIC_STORE_BOOL(&pAppConfiguration->sigInt, FALSE);
    ATOMIC_STORE_BOOL(&pAppConfiguration->mediaThreadStarted, FALSE);
    ATOMIC_STORE_BOOL(&pAppConfiguration->terminateApp, FALSE);
    ATOMIC_STORE_BOOL(&pAppConfiguration->restartSignalingClient, FALSE);
    ATOMIC_STORE_BOOL(&pAppConfiguration->peerConnectionConnected, FALSE);

    pAppConfiguration->iceUriCount = 0;

    CHK_STATUS((createConnectionMsqQ(&pAppConfiguration->pRemotePeerPendingSignalingMessages)));
    CHK_STATUS(
        (appHashTableCreateWithParams(APP_HASH_TABLE_BUCKET_COUNT, APP_HASH_TABLE_BUCKET_LENGTH, &pAppConfiguration->pRemoteRtcPeerConnections)));

    // the initialization of media source.
    CHK_STATUS((initMediaSource(&pAppConfiguration->pMediaContext)));
    CHK_STATUS((linkMeidaSinkHook(pAppConfiguration->pMediaContext, onMediaSinkHook, pAppConfiguration)));
    CHK_STATUS((linkMeidaEosHook(pAppConfiguration->pMediaContext, onMediaEosHook, pAppConfiguration)));
    pAppConfiguration->mediaSource = runMediaSource;
    DLOGD("The intialization of the media source is completed successfully");

    // Initalize KVS WebRTC. This must be done before anything else, and must only be done once.
    CHK_STATUS((initWebRtc(pAppConfiguration)));
    DLOGD("The initialization of WebRTC  is completed successfully");
    gAppConfiguration = pAppConfiguration;

    // Start the cert pre-gen timer callback
    if (APP_PRE_GENERATE_CERT) {
        CHK_LOG_ERR((retStatus = appTimeQueueAdd(pAppConfiguration->timerQueueHandle, 0, APP_PRE_GENERATE_CERT_PERIOD, pregenerateCertTimerCallback,
                                                 (UINT64) pAppConfiguration, &pAppConfiguration->pregenerateCertTimerId)));
    }
CleanUp:

    if (STATUS_FAILED(retStatus) && pAppConfiguration != NULL) {
        freeApp(&pAppConfiguration);
    }

    if (ppAppConfiguration != NULL) {
        *ppAppConfiguration = pAppConfiguration;
    }

    return retStatus;
}