acm_iarm_interface.cpp

/*
 * If not stated otherwise in this file or this component's Licenses.txt file the
 * following copyright and licenses apply:
 *
 * Copyright 2016 RDK Management
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
*/
#include "acm_iarm_interface.h"
#include "audiocapturemgr_iarm.h"
#include <string>
#include <string.h>
#include <sstream>
#include "libIARM.h"
#include "libIBus.h"
#include "safec_lib.h"
 
using namespace audiocapturemgr;
 
 
 
static acm_iarm_interface g_singleton;
 
static unsigned int ticker = 0;
std::string audio_filename_prefix = AUDIOCAPTUREMGR_FILENAME_PREFIX;
std::string audio_file_path = AUDIOCAPTUREMGR_FILE_PATH;
static std::string get_suffix()
{
    std::ostringstream stream;
    stream << ticker++;
    std::string outstring = stream.str();
    return outstring;
}
 
static void request_callback(void * data, std::string &file, int result)
{
        errno_t rc = -1;
        if(0 != result)
        {
                ERROR("Failed to grab sample.\n");
        }
        else
        {
                iarmbus_notification_payload_t payload;
                rc = strcpy_s(payload.dataLocator, sizeof(payload.dataLocator), file.c_str());
                if(rc == EOK)
                {
                        int ret = IARM_Bus_BroadcastEvent(IARMBUS_AUDIOCAPTUREMGR_NAME, DATA_CAPTURE_IARM_EVENT_AUDIO_CLIP_READY, &payload, sizeof(payload));
                        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
                }
                else
                {
                        ERR_CHK(rc);
                        WARN("Incoming filename is too big for payload buffer.\n");
                }
        }
}
 
static IARM_Result_t enable_capture(void * arg)
{
        g_singleton.enable_capture_handler(arg);
        return IARM_RESULT_SUCCESS;
}
static IARM_Result_t request_sample(void * arg)
{
        g_singleton.get_sample_handler(arg);
        return IARM_RESULT_SUCCESS;
}
 
acm_iarm_interface::acm_iarm_interface() : m_is_active(false), m_enable_audio_input(false),  m_client(NULL)
{
        INFO("Enter\n");
}
acm_iarm_interface::~acm_iarm_interface()
{
        INFO("Enter\n");
}
 
acm_iarm_interface * acm_iarm_interface::get_instance()
{
        return &g_singleton;
}
 
int acm_iarm_interface::activate(music_id_client * client)
{
        int ret;
        INFO("Enter\n");
        if(NULL != m_client)
        {
                ERROR("ACM IARM interface is already in use by another client.\n");
                ret = -1;
        }
        else
        {
                m_client = client;
        }
 
        //TODO: add early exit for each of the failures below
        ret = IARM_Bus_Init(IARMBUS_AUDIOCAPTUREMGR_NAME);
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
 
        ret = IARM_Bus_Connect();
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
 
        ret =  IARM_Bus_RegisterEvent(IARMBUS_MAX_ACM_EVENT);
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
 
        ret = IARM_Bus_RegisterCall(IARMBUS_AUDIOCAPTUREMGR_ENABLE, enable_capture);
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
 
        ret = IARM_Bus_RegisterCall(IARMBUS_AUDIOCAPTUREMGR_REQUEST_SAMPLE, request_sample);
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
 
        return ret;
}
int acm_iarm_interface::deactivate()
{
        int ret;
        INFO("Enter\n");
        ret = IARM_Bus_Disconnect();
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
        ret = IARM_Bus_Term();
        REPORT_IF_UNEQUAL(IARM_RESULT_SUCCESS, ret);
        if(m_enable_audio_input)
        {
                m_client->stop();
                m_enable_audio_input = false;
        }
        m_client = NULL;
        return ret;
}
 
int acm_iarm_interface::enable_capture_handler(void * arg)
{
        iarmbus_enable_payload_t *data = static_cast <iarmbus_enable_payload_t *> (arg);
        unsigned int incoming_duration = static_cast <int> (data->max_duration);
        unsigned int max_supported_duration = m_client->get_max_supported_duration();
 
        if(incoming_duration > max_supported_duration)
        {
                ERROR("Incoming duration %d is too long.\n", incoming_duration);
                data->result = max_supported_duration; // Return the max supported duration if incoming value is too high.
        }
        else
        {
                //TODO: if incoming is 0, turn off precapturing. If it isn't, turn it back on and set duration. 
                m_client->set_precapture_duration(incoming_duration);
                if(0 == incoming_duration)
                {
                        if(true == m_enable_audio_input)
                        {
                                INFO("Disabling audio capture.\n");
                                m_client->stop();
                                m_enable_audio_input = false;
                        }
                }
                else if(false == m_enable_audio_input)
                {
                        INFO("Enabling audio capture.\n");
                        m_client->start();
                        m_enable_audio_input = true;
                }
                data->result = ACM_RESULT_SUCCESS;
        }
        return 0;
}
 
 
int acm_iarm_interface::get_sample_handler(void * arg)
{
        int ret = 0;
        iarmbus_request_payload_t *data = static_cast <iarmbus_request_payload_t *> (arg);
        if(false == m_enable_audio_input)
        {
                ERROR("Audio capture is currently disabled!\n");
                data->result = ACM_RESULT_DURATION_OUT_OF_BOUNDS;
                return 0;
        }
        data->result = ACM_RESULT_SUCCESS;
        std::string filename = audio_file_path + audio_filename_prefix + get_suffix();
 
        if(data->is_precapture)
        {
                ret = m_client->grab_precaptured_sample(filename);
                if(0 == ret)
                {
                        /* Precapture is immediate. Notify now.*/
                        request_callback(NULL, filename, 0);
                }
        }
        else
        {
                unsigned int duration = static_cast <unsigned int> (data->duration);    
                if(duration <= m_client->get_max_supported_duration())
                {
                        ret = m_client->grab_fresh_sample(filename, duration, &request_callback, NULL);
                }
                else
                {
                        ERROR("Duration out of bounds!\n");
                        data->result = ACM_RESULT_DURATION_OUT_OF_BOUNDS;
                }
        }
        /*Note: tricky condition check. ret is also zero if it's an out-of-bounds error, 
         * but in that case, result is already updated.*/
        if(0 != ret)
        {
                data->result = ACM_RESULT_GENERAL_FAILURE;
        }
        return 0;
}
 
void acm_iarm_interface::set_filename_prefix(std::string &prefix)
{
        audio_filename_prefix = prefix; 
}