READY : 'READY'
};
+function FMRadioInterruptCallbackManager() {
+
+ this.oninterrupted;
+ this.oninterruptfinished;
+};
+
+FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedCBSwitch = function(args) {
+ if (args.action == 'oninterrupted')
+ this.oninterrupted(args.reason);
+ else
+ this.oninterruptfinished();
+};
+
+FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedSet = function(oi, oif) {
+ this.oninterrupted = oi;
+ this.oninterruptfinished = oif;
+ native_.addListener('FMRadio_Interrupted', this.FMRadioInterruptedCBSwitch
+ .bind(this));
+};
+
+FMRadioInterruptCallbackManager.prototype.FMRadioInterruptedUnset = function() {
+ native_.removeListener('FMRadio_Interrupted');
+};
+
+function FMRadioScanCallbackManager() {
+
+ this.radioScanCallback;
+
+};
+
+FMRadioScanCallbackManager.prototype.FMRadioScanCBSwitch = function(args) {
+ this.radioScanCallback(args.frequency);
+};
+
+FMRadioScanCallbackManager.prototype.FMRadioScanSet = function(cb) {
+ this.radioScanCallback = cb;
+ native_.addListener('FMRadio_Onfrequencyfound',
+ this.FMRadioScanCBSwitch.bind(this));
+};
+
+FMRadioScanCallbackManager.prototype.FMRadioScanUnset = function() {
+ native_.removeListener('FMRadio_Onfrequencyfound');
+};
+
+function FMRadioAntennaChangeCallbackManager() {
+
+ this.onchange;
+
+};
+
+FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaCBSwitch = function(args) {
+ this.onchange(args.connected);
+};
+
+FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaChangeSet = function(cb) {
+ this.onchange = cb;
+ native_.addListener('FMRadio_Antenna', this.FMRadioAntennaCBSwitch
+ .bind(this));
+};
+
+FMRadioAntennaChangeCallbackManager.prototype.FMRadioAntennaUnset = function() {
+ native_.removeListener('FMRadio_Antenna');
+};
+
+var antennaCBmanager = new FMRadioAntennaChangeCallbackManager();
+var interruptedCBmanager = new FMRadioInterruptCallbackManager();
+var scanCBmanager = new FMRadioScanCallbackManager();
+
function FMRadioManager() {
Object.defineProperties(this, {
'frequency' : {
}
},
'mute' : {
- value : 'TEST',
- writable : false,
- enumerable : true
+ enumerable : true,
+ get : muteGetter,
+ set : muteSetter
}
});
+ function muteGetter() {
+ var ret = native_.callSync('FMRadio_MuteGetter');
+ return native_.getResultObject(ret);
+ }
+
+ function muteSetter() {
+
+ var args = validator_.validateArgs(arguments, [ {
+ name : 'mute',
+ type : types_.BOOLEAN
+ } ]);
+ var ret = native_.callSync('FMRadio_MuteSetter', args);
+ }
+
function radioStateGetter() {
var ret = native_.callSync('FMRadio_RadioStateGetter');
+
return native_.getResultObject(ret);
}
function isAntennaConnectedGetter() {
var ret = native_.callSync('FMRadio_IsAntennaConnectedGetter');
+
return native_.getResultObject(ret);
}
function signalStrengthGetter() {
var ret = native_.callSync('FMRadio_SignalStrengthGetter');
+
return native_.getResultObject(ret);
}
function frequencyGetter() {
var ret = native_.callSync('FMRadio_FrequencyGetter');
+
return native_.getResultObject(ret);
}
if (args.frequency) {
if (args.frequency < this.frequencyLowerBound
|| args.frequency > this.frequencyUpperBound)
- throw new tizen.WebAPIException(0,
+ throw new tizen.WebAPIException(
tizen.WebAPIException.INVALID_VALUES_ERR,
'Frequency out of bounds');
}
};
FMRadioManager.prototype.scanStart = function() {
+ var args = validator_.validateArgs(arguments, [ {
+ name : 'radioScanCallback',
+ type : types_.LISTENER,
+ values : [ 'onfrequencyfound', 'onfinished' ]
+ }, {
+ name : 'errorCallback',
+ type : types_.FUNCTION,
+ optional : true,
+ nullable : true
+ } ]);
+
+ scanCBmanager.FMRadioScanSet(args.radioScanCallback.onfrequencyfound);
+
+ var ret = native_.call('FMRadio_ScanStart', {}, function(result) {
+ if (native_.isFailure(result)) {
+ if (args.errorCallback)
+ args.errorCallback(native_.getErrorObject(result));
+ } else {
+ scanCBmanager.FMRadioScanUnset();
+ args.radioScanCallback.onfinished(result.frequencies);
+ }
+ });
};
FMRadioManager.prototype.stop = function() {
};
FMRadioManager.prototype.scanStop = function() {
+ var args = validator_.validateArgs(arguments, [ {
+ name : 'successCallback',
+ type : types_.FUNCTION,
+ optional : true,
+ nullable : true
+ }, {
+ name : 'errorCallback',
+ type : types_.FUNCTION,
+ optional : true,
+ nullable : true
+ } ]);
-};
-
-function FMRadioInterruptManager() {
-
- this.oninterrupted;
- this.oninterruptfinished;
-};
+ var ret = native_.call('FMRadio_ScanStop', {}, function(result) {
+ if (native_.isFailure(result)) {
+ if (args.errorCallback)
+ args.errorCallback(native_.getErrorObject(result));
+ } else {
-FMRadioInterruptManager.prototype.FMRadioInterruptedCBSwitch = function(args) {
- if (args.action == 'oninterrupted') {
- if (this.oninterrupted) {
- this.oninterrupted();
- }
- } else {
+ args.successCallback();
- if (this.oninterruptfinished) {
- this.oninterruptfinished();
}
- }
-};
-
-FMRadioInterruptManager.prototype.FMRadioInterruptedSet = function(oi, oif) {
- this.oninterrupted = oi;
- this.oninterruptfinished = oif;
- native_.addListener('FMRadio_Interrupted', this.FMRadioInterruptedCBSwitch
- .bind(this));
+ });
};
-var intmgr = new FMRadioInterruptManager();
-
FMRadioManager.prototype.setFMRadioInterruptedListener = function() {
var args = validator_.validateArgs(arguments, [ {
- name : 'eventCallback',
+ name : 'interruptCallback',
type : types_.LISTENER,
values : [ 'oninterrupted', 'oninterruptfinished' ]
} ]);
- intmgr.FMRadioInterruptedSet(args.eventCallback.oninterrupted,
- args.eventCallback.oninterruptfinished)
+ interruptedCBmanager.FMRadioInterruptedSet(args.interruptCallback.oninterrupted,
+ args.interruptCallback.oninterruptfinished)
var ret = native_.callSync('FMRadio_SetFMRadioInterruptedListener');
FMRadioManager.prototype.unsetFMRadioInterruptedListener = function() {
- // TODO intmgr unset
+ interruptedCBmanager.FMRadioInterruptedUnset();
var ret = native_.callSync('FMRadio_UnsetFMRadioInterruptedListener');
};
FMRadioManager.prototype.setAntennaChangeListener = function() {
var args = validator_.validateArgs(arguments, [ {
- name : 'eventCallback',
+ name : 'changeCallback',
type : types_.LISTENER,
values : [ 'onchange' ]
} ]);
- // TODO listener manager
+ antennaCBmanager.FMRadioAntennaChangeSet(args.changeCallback);
var ret = native_.callSync('FMRadio_SetAntennaChangeListener');
};
FMRadioManager.prototype.unsetAntennaChangeListener = function() {
- // TODO listener manager
+ antennaCBmanager.FMRadioAntennaUnset();
var ret = native_.callSync('FMRadio_UnsetAntennaChangeListener');
};
REGISTER_SYNC("FMRadio_UnsetAntennaChangeListener", UnsetAntennaChangeListener);
REGISTER_SYNC("FMRadio_FrequencyGetter", FrequencyGetter);
REGISTER_SYNC("FMRadio_SignalStrengthGetter", SignalStrengthGetter);
- REGISTER_SYNC("FMRadio_IsAntennaConnectedGetter", AntenaGetter);
+ REGISTER_SYNC("FMRadio_IsAntennaConnectedGetter", AntennaGetter);
REGISTER_SYNC("FMRadio_RadioStateGetter", StateGetter);
+ REGISTER_SYNC("FMRadio_MuteSetter", MuteSetter);
+ REGISTER_SYNC("FMRadio_MuteGetter", MuteGetter);
#undef REGISTER_SYNC
#define REGISTER_ASYNC(c,x) \
RegisterHandler(c, std::bind(&RadioInstance::x, this, _1, _2));
return instance;
}
- void RadioInstance::AntenaGetter(const picojson::value& args,
- picojson::object& out){
- }
+ void RadioInstance::MuteGetter(const picojson::value& args,
+ picojson::object& out)
+ {
+ bool mute = FMRadioManager::GetInstance(0)->MuteGetter();
+ ReportSuccess(picojson::value(mute),out);
+ }
+
+ void RadioInstance::MuteSetter(const picojson::value& args,
+ picojson::object& out)
+ {
+ FMRadioManager::GetInstance(0)->MuteSetter(args);
+ }
+
+ void RadioInstance::AntennaGetter(const picojson::value& args,
+ picojson::object& out)
+ {
+ LoggerD(".cc AntennaGetter()");
+ bool Antenna = FMRadioManager::GetInstance(0)->AntennaGetter();
+ ReportSuccess(picojson::value(Antenna),out);
+ }
- void RadioInstance::StateGetter(const picojson::value& args,
- picojson::object& out){
- }
+ void RadioInstance::StateGetter(const picojson::value& args,
+ picojson::object& out)
+ {
+ LoggerD(".cc StateGetter()");
+ std::string state = FMRadioManager::GetInstance(0)->StateGetter();
+ ReportSuccess(picojson::value(state),out);
+ }
void RadioInstance::FrequencyGetter(const picojson::value& args,
picojson::object& out)
{
LoggerD(".cc FrequencyGetter()");
- double freq = FMRadioManager::GetInstance()->FrequencyGetter();
+ double freq = FMRadioManager::GetInstance(0)->FrequencyGetter();
ReportSuccess(picojson::value(freq),out);
}
void RadioInstance::SignalStrengthGetter(const picojson::value& args,
picojson::object& out)
- {
- LoggerD(".cc SignalStrengthGetter()");
- double strength = FMRadioManager::GetInstance()->SignalStrengthGetter();
- ReportSuccess(picojson::value(strength),out);
- }
+ {
+ LoggerD(".cc SignalStrengthGetter()");
+ double strength = FMRadioManager::GetInstance(0)->SignalStrengthGetter();
+ ReportSuccess(picojson::value(strength),out);
+ }
void RadioInstance::InstanceReportSuccess(picojson::object& out) {
LoggerD(".cc InstanceReportSuccess()");
void RadioInstance::SeekUp(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc SeekUp()");
- FMRadioManager::GetInstance()->SeekUp(args);
+ FMRadioManager::GetInstance(0)->SeekUp(args);
}
void RadioInstance::SeekDown(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc SeekDown()");
- FMRadioManager::GetInstance()->SeekDown(args);
+ FMRadioManager::GetInstance(0)->SeekDown(args);
}
void RadioInstance::Start(const picojson::value& args,
void RadioInstance::ScanStart(const picojson::value& args,
picojson::object& out) {
- FMRadioManager::GetInstance()->ScanStart(args);
+ FMRadioManager::GetInstance(0)->ScanStart(args);
}
void RadioInstance::ScanStop(const picojson::value& args,
picojson::object& out) {
- FMRadioManager::GetInstance()->ScanStop(args);
+ FMRadioManager::GetInstance(0)->ScanStop(args);
}
void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc SetFMRadioInterruptedListener()");
- FMRadioManager::GetInstance()->SetFMRadioInterruptedListener();
+ FMRadioManager::GetInstance(0)->SetFMRadioInterruptedListener();
}
void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc UnsetFMRadioInterruptedListener()");
- FMRadioManager::GetInstance()->UnsetFMRadioInterruptedListener();
+ FMRadioManager::GetInstance(0)->UnsetFMRadioInterruptedListener();
}
void RadioInstance::SetAntennaChangeListener(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc SetAntennaChangeListener()");
- FMRadioManager::GetInstance()->SetAntennaChangeListener();
+ FMRadioManager::GetInstance(0)->SetAntennaChangeListener();
}
void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args,
picojson::object& out) {
LoggerD(".cc UnsetAntennaChangeListener()");
- FMRadioManager::GetInstance()->UnsetAntennaChangeListener();
+ FMRadioManager::GetInstance(0)->UnsetAntennaChangeListener();
}
}
#include "radio_manager.h"
#include <unistd.h>
-
#include <cstring>
#include <algorithm>
-
#include <glib.h>
-
+#include <runtime_info.h>
#include <vconf.h>
#include "common/logger.h"
namespace extension {
namespace radio {
+char* state_array[] = { "READY", "PLAYING", "SCANNING" ,""};
static const double FREQ_LOWER = 87.5;
-typedef struct RadioSeekCBstruct_
-{
- double cbid;
- radio_h radio_instance;
-} RadioSeekCBstruct;
-
-
static void createEventSuccess(picojson::object& obj,double callbackId)
{
obj.insert(std::make_pair("callbackId", callbackId));
obj.insert(std::make_pair("status", picojson::value("success")));
+
picojson::value event = picojson::value(obj);
RadioInstance::getInstance().PostMessage(event.serialize().c_str());
}
{
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
+
createEventSuccess(obj,callbackId);
}
int FMRadioManager::Create()
{
- if (radio_instance==NULL)
+ if (radio_instance == NULL)
{
int err = radio_create(&radio_instance);
if(err){
radio_instance=NULL;
}
return err;
-
}
return 0;
}
+bool FMRadioManager::MuteGetter()
+{
+ bool muted = false;
+ int err = radio_is_muted (radio_instance, &muted);
+ if (RADIO_ERROR_NONE != err) {
+ LoggerE("radio_is_muted %d",err);
+ }
+ return muted;
+}
+
+void FMRadioManager::MuteSetter(const picojson::value& args)
+{
+ bool mute = args.get("mute").get<bool>();
+
+ int err = radio_set_mute (radio_instance, mute);
+ if (err)
+ {
+ LoggerE("radio_set_mute %d",err);
+ }
+}
+
+bool FMRadioManager::AntennaGetter()
+{
+ bool connected = false;
+ int err = runtime_info_get_value_bool (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED , &connected);
+
+ if (err)
+ {
+ return false;
+ }
+ return connected;
+}
+
+
+
+char* FMRadioManager::StateGetter()
+{
+ LoggerD("FMRadioManager::FrequencyGetter()");
+
+ radio_state_e state;
+
+ int err = radio_get_state (radio_instance, &state);
+ if (err)
+ {
+ return state_array[3]; // returns ""
+ }
+
+ return state_array[static_cast<int>(state)];
+}
+
double FMRadioManager::FrequencyGetter()
{
int freq;
}
return static_cast<double>(freq/1000);
}
+
double FMRadioManager::SignalStrengthGetter()
{
int stren;
LoggerE("radio_get_signal_strength()");
return 0;
}
+
return static_cast<double>(stren);
}
LoggerD("radio_destroy() error %d",err);
}
-FMRadioManager* FMRadioManager::GetInstance()
+FMRadioManager* FMRadioManager::GetInstance(bool safe)
{
static FMRadioManager instance;
- instance.Create();
+ int err=instance.Create();
+ if(safe)
+ {
+ CheckErr("radio_create",err);
+ }
+ LoggerD("FMRadioManager::GetInstance()");
+
return &instance;
}
void FMRadioManager::CheckErr(string str,int err)
{
- if(err)
+
+ LoggerE("%s() error %d",str.c_str(),err);
+
+ if(RADIO_ERROR_NONE == err)
{
- LoggerE("%s() error %d",str.c_str(),err);
+ return;
}
-
- if (err==RADIO_ERROR_INVALID_PARAMETER )
+ else if (RADIO_ERROR_INVALID_PARAMETER == err)
{
throw common::InvalidValuesException(str);
}
- else if(err==RADIO_ERROR_INVALID_STATE)
+ else if(RADIO_ERROR_INVALID_STATE == err)
{
- throw common::InvalidValuesException(str);
+ throw common::InvalidStateException(str);
}
- else if(err==RADIO_ERROR_SOUND_POLICY)
+ else if(RADIO_ERROR_SOUND_POLICY == err)
{
throw common::UnknownException(str);
}
- else if(err==RADIO_ERROR_NOT_SUPPORTED)
+ else if(RADIO_ERROR_NOT_SUPPORTED == err)
{
throw common::ServiceNotAvailableException(str);
}
{
LoggerD("FMRadioManager::Start(%f)",freq);
- int err = radio_set_frequency (radio_instance, freq);
+ int err = radio_set_frequency (radio_instance, freq*1000);
CheckErr("radio_set_frequency",err);
err= radio_start(radio_instance);
PlatformException FMRadioManager::GetException(char * name,int err)
{
- const int SIZE = 200;
- char buff[SIZE];
- snprintf(buff,SIZE-1,"%s:%d",name,err);
- //TODO Split exception types
- return UnknownException(buff);
+ string buff=string(name);
+ buff+=" : ";
+ buff+=to_string(err);
+ if(RADIO_ERROR_INVALID_PARAMETER == err)
+ {
+ return InvalidValuesException(buff);
+ }
+ else if(RADIO_ERROR_INVALID_OPERATION == err)
+ {
+ return UnknownException(buff);
+ }
+ else if(RADIO_ERROR_INVALID_STATE == err)
+ {
+ return InvalidStateException(buff);
+ }
+
+ else if(RADIO_ERROR_SOUND_POLICY == err)
+ {
+ return UnknownException(buff);
+ }
+ else if(RADIO_ERROR_PERMISSION_DENIED == err)
+ {
+ return UnknownException(buff);
+ }
+ else if(RADIO_ERROR_OUT_OF_MEMORY == err)
+ {
+ return UnknownException(buff);
+ }
+ else
+ {
+ return UnknownException(buff);
+ }
}
void FMRadioManager::RadioSeekCB(int frequency, void *user_data)
{
- RadioSeekCBstruct * data = static_cast<RadioSeekCBstruct*>(user_data);
- double callbackId = data->cbid;
- int err = radio_set_frequency(static_cast<radio_h>(data->radio_instance),frequency);
+ double * id = static_cast<double*>(user_data);
+
+ int err = radio_set_frequency(*(FMRadioManager::GetInstance(0)->GetRadioInstance()),frequency);
if (RADIO_ERROR_NONE != err)
{
- createEventFail(callbackId,GetException("radio_set_frequency",err));
+ createEventFail(*id,GetException("radio_set_frequency",err));
}
else
{
- createEventSuccess(callbackId);
+ createEventSuccess(*id);
}
- delete data;
+ delete id;
+}
+
+radio_h* FMRadioManager::GetRadioInstance()
+{
+ return &radio_instance;
}
void FMRadioManager::SeekUp(const picojson::value& args){
- double callbackId = args.get("callbackId").get<double>();
- RadioSeekCBstruct *data= new RadioSeekCBstruct;
- data->cbid = callbackId;
- data->radio_instance = radio_instance;
- int err = radio_seek_up (radio_instance,RadioSeekCB,static_cast<void *>(data));
+ double * callbackId = new double(args.get("callbackId").get<double>());
+
+ int err = radio_seek_up (radio_instance,RadioSeekCB,static_cast<void *>(callbackId));
+
if(RADIO_ERROR_NONE != err)
{
- delete data;
- createEventFail(callbackId,GetException("radio_set_frequency",err));
- }
+ delete callbackId;
+ createEventFail(*callbackId,GetException("radio_set_frequency",err));
+ }
}
void FMRadioManager::SeekDown(const picojson::value& args){
- double callbackId = args.get("callbackId").get<double>();
- RadioSeekCBstruct *data= new RadioSeekCBstruct;
- data->cbid = callbackId;
- data->radio_instance = radio_instance;
- int err = radio_seek_down (radio_instance,RadioSeekCB,static_cast<void *>(data));
- if(RADIO_ERROR_NONE != err)
- {
- delete data;
- createEventFail(callbackId,GetException("radio_set_frequency",err));
- }
+ double * callbackId = new double(args.get("callbackId").get<double>());
+
+ int err = radio_seek_down (radio_instance,RadioSeekCB,static_cast<void *>(callbackId));
+
+ if(RADIO_ERROR_NONE != err)
+ {
+
+ delete callbackId;
+ createEventFail(*callbackId,GetException("radio_set_frequency",err));
+ }
+}
+
+void FMRadioManager::ScanStartCB(int frequency, void *user_data)
+{
+ std::vector<double> * freqs = FMRadioManager::GetInstance()->GetFreqs();
+ freqs->push_back(static_cast<double>(frequency));
+
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("frequency", picojson::value(static_cast<double>(frequency))));
+ obj.insert(std::make_pair("listenerId", "FMRadio_Onfrequencyfound"));
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+
+}
+
+void FMRadioManager::ScanStopCB(void *user_data)
+{
+ createEventSuccess( *(static_cast<double*>(user_data)));
+ delete static_cast<double*>(user_data);
+
+}
+
+std::vector<double> * FMRadioManager::GetFreqs()
+{
+ return &freqs;
+}
+
+void FMRadioManager::ScanCompleteCB(void *user_data)
+{
+ double * id= static_cast<double*>(user_data);
+
+ std::vector<double> * freqs = FMRadioManager::GetInstance()->GetFreqs();
+
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("name", picojson::value("onfinished")));
+
+ std::vector<picojson::value> vect = std::vector<picojson::value> ();
+ for (std::vector<double>::iterator it = freqs->begin() ; it != freqs->end(); ++it)
+ {
+ vect.push_back(picojson::value(*it));
+ }
+
+ obj.insert(std::make_pair("frequencies", picojson::value(vect)));
+ createEventSuccess(obj,*id);
+
+ delete id;
}
-void FMRadioManager::ScanStart(const picojson::value& args){
- LoggerD("FMRadioManager::StartScan()");
+
+
+void FMRadioManager::ScanStart(const picojson::value& args)
+{
+ LoggerD("FMRadioManager::ScanStart()");
+
+ double *callbackId = new double(args.get("callbackId").get<double>());
+
+ freqs = std::vector<double>();
+
+ int err =radio_set_scan_completed_cb(radio_instance,ScanCompleteCB,callbackId);
+ if(err)
+ {
+ createEventFail(*callbackId,GetException("radio_set_scan_completed_cb %d",err));
+ delete callbackId;
+ return;
+ }
+
+ err = radio_scan_start (radio_instance, ScanStartCB, NULL);
+ if(err)
+ {
+ radio_unset_scan_completed_cb(radio_instance);
+ createEventFail(*callbackId,GetException("radio_scan_start %d",err));
+ delete callbackId;
+ }
+
}
void FMRadioManager::ScanStop(const picojson::value& args){
- LoggerD("FMRadioManager::StopScan()");
+ LoggerD("FMRadioManager::ScanStop()");
+
+ double* callbackId = new double(args.get("callbackId").get<double>());
+
+ int ret = radio_unset_scan_completed_cb(radio_instance);
+ if(ret)
+ {
+ createEventFail(*callbackId,GetException("radio_unset_scan_completed_cb %d",ret));
+ delete callbackId;
+ return;
+ }
+
+ ret = radio_scan_stop (radio_instance, ScanStopCB, callbackId);
+ if(ret)
+ {
+ createEventFail(*callbackId,GetException("radio_scan_stop %d",ret));
+ delete callbackId;
+ }
+
}
+
+string FMRadioManager::TranslateCode(int code)
+{
+ if (RADIO_INTERRUPTED_BY_MEDIA == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_MEDIA");
+ }
+ else if(RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA");
+ }
+ else if(RADIO_INTERRUPTED_BY_CALL == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_CALL");
+ }
+ else if(RADIO_INTERRUPTED_BY_EARJACK_UNPLUG == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_EARJACK_UNPLUG");
+ }
+ else if(RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_RESOURCE_CONFLICT");
+ }
+ else if(RADIO_INTERRUPTED_BY_ALARM == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_ALARM");
+ }
+ else if(RADIO_INTERRUPTED_BY_EMERGENCY == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_EMERGENCY");
+ }
+ else if(RADIO_INTERRUPTED_BY_MEDIA == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_RESUMABLE_MEDIA");
+ }
+ else if(RADIO_INTERRUPTED_BY_NOTIFICATION == code)
+ {
+ return string("RADIO_INTERRUPTED_BY_NOTIFICATION");
+ }
+}
+
+void FMRadioManager::RadioInterruptedCB(radio_interrupted_code_e code, void *user_data)
+{
+
+ if(code == RADIO_INTERRUPTED_COMPLETED )
+ {
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("action", picojson::value("oninterruptfinished")));
+ obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted"));
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+ }
+ else
+ {
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+ obj.insert(std::make_pair("action", picojson::value("oninterrupted")));
+
+ obj.insert(std::make_pair("reason", TranslateCode(code)));
+
+ obj.insert(std::make_pair("listenerId", "FMRadio_Interrupted"));
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+ }
+
+}
+
void FMRadioManager::SetFMRadioInterruptedListener(){
LoggerD("FMRadioManager::SetFMRadioInterruptedListener()");
+ int err = radio_set_interrupted_cb (radio_instance, RadioInterruptedCB, NULL);
+ if(RADIO_ERROR_NONE != err)
+ {
+ CheckErr("radio_set_interrupted_cb",err);
+ }
}
void FMRadioManager::UnsetFMRadioInterruptedListener(){
LoggerD("FMRadioManager::UnsetFMRadioInterruptedListener()");
+ int err = radio_unset_interrupted_cb(radio_instance);
+ if(RADIO_ERROR_NONE != err)
+ {
+ CheckErr("radio_unset_interrupted_cb",err);
+ }
}
+
+void FMRadioManager::RadioAntennaCB(runtime_info_key_e key, void *user_data)
+{
+ LoggerD("FMRadioManager::RadioAntennaCB()");
+
+ bool connected=false;
+ int err = runtime_info_get_value_bool (key, &connected);
+ if(RADIO_ERROR_NONE != err)
+ {
+ LoggerE("FMRadioManager::RadioAntennaCB() runtime_info_get_value_bool %d",err);
+ }
+
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+
+ obj.insert(std::make_pair("connected", picojson::value(connected)));
+
+ obj.insert(std::make_pair("listenerId", "FMRadio_Antenna"));
+ RadioInstance::getInstance().PostMessage(event.serialize().c_str());
+
+}
+
void FMRadioManager::SetAntennaChangeListener(){
LoggerD("FMRadioManager::SetAntennaChangeListener()");
+ int err = runtime_info_set_changed_cb (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED ,
+ RadioAntennaCB, NULL);
+ if(RADIO_ERROR_NONE != err)
+ {
+ CheckErr("runtime_info_set_changed_cb",err);
+ }
+
}
void FMRadioManager::UnsetAntennaChangeListener(){
- LoggerD("FMRadioManager::UnetAntennaChangeListener()");
+ LoggerD("FMRadioManager::UnsetAntennaChangeListener()");
+ int err = runtime_info_unset_changed_cb (RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED);
+ if(RADIO_ERROR_NONE != err)
+ {
+ CheckErr("runtime_info_unset_changed_cb",err);
+ }
+
}
} // namespace
projects / platform / core / api / webapi-plugins.git / commitdiff