// Call any property of ClientRequest._Incoming
bool iotjs_https_jcallback(iotjs_https_t* https_data, const char* property,
const iotjs_jargs_t* jarg, bool resultvalue) {
iotjs_jval_t* jthis = iotjs_https_jthis_from_https(https_data);
bool retval = true;
if (iotjs_jval_is_null(jthis))
return retval;
iotjs_jval_t jincoming =
iotjs_jval_get_property(jthis, IOTJS_MAGIC_STRING__INCOMING);
iotjs_jval_t cb = iotjs_jval_get_property(&jincoming, property);
IOTJS_ASSERT(iotjs_jval_is_function(&cb));
if (!resultvalue) {
iotjs_make_callback(&cb, &jincoming, jarg);
} else {
iotjs_jval_t result =
iotjs_make_callback_with_result(&cb, &jincoming, jarg);
retval = iotjs_jval_as_boolean(&result);
iotjs_jval_destroy(&result);
}
iotjs_jval_destroy(&jincoming);
iotjs_jval_destroy(&cb);
return retval;
}
static void iotjs_spi_set_configuration(iotjs_spi_t* spi,
const iotjs_jval_t* joptions) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi);
#if defined(__linux__)
iotjs_jval_t jdevice =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_DEVICE);
_this->device = iotjs_jval_as_string(&jdevice);
iotjs_jval_destroy(&jdevice);
#elif defined(__NUTTX__) || defined(__TIZENRT__)
iotjs_jval_t jbus = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BUS);
_this->bus = iotjs_jval_as_number(&jbus);
iotjs_jval_destroy(&jbus);
#endif
iotjs_jval_t jmode =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE);
_this->mode = (SpiMode)iotjs_jval_as_number(&jmode);
iotjs_jval_destroy(&jmode);
iotjs_jval_t jchip_select =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT);
_this->chip_select = (SpiChipSelect)iotjs_jval_as_number(&jchip_select);
iotjs_jval_destroy(&jchip_select);
iotjs_jval_t jmax_speed =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED);
_this->max_speed = iotjs_jval_as_number(&jmax_speed);
iotjs_jval_destroy(&jmax_speed);
iotjs_jval_t jbits_per_word =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD);
_this->bits_per_word = (SpiOrder)iotjs_jval_as_number(&jbits_per_word);
iotjs_jval_destroy(&jbits_per_word);
iotjs_jval_t jbit_order =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER);
_this->bit_order = (SpiOrder)iotjs_jval_as_number(&jbit_order);
iotjs_jval_destroy(&jbit_order);
iotjs_jval_t jloopback =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK);
_this->loopback = iotjs_jval_as_boolean(&jloopback);
iotjs_jval_destroy(&jloopback);
}
// Calls next tick callbacks registered via `process.nextTick()`.
bool iotjs_process_next_tick() {
const iotjs_jval_t* process = iotjs_module_get(MODULE_PROCESS);
iotjs_jval_t jon_next_tick =
iotjs_jval_get_property(process, IOTJS_MAGIC_STRING__ONNEXTTICK);
IOTJS_ASSERT(iotjs_jval_is_function(&jon_next_tick));
iotjs_jval_t jres =
iotjs_jhelper_call_ok(&jon_next_tick, iotjs_jval_get_undefined(),
iotjs_jargs_get_empty());
IOTJS_ASSERT(iotjs_jval_is_boolean(&jres));
bool ret = iotjs_jval_as_boolean(&jres);
iotjs_jval_destroy(&jres);
iotjs_jval_destroy(&jon_next_tick);
return ret;
}
/* Default configuration:
*{
* mode: spi.MODE[0],
* chipSelect: spi.CHIPSELECT.NONE,
* maxSpeed: 500000,
* bitsPerWord: 8,
* bitOrder: spi.BITORDER.MSB,
* loopback: false
* }
*/
static jerry_value_t spi_set_configuration(iotjs_spi_t* spi,
jerry_value_t joptions) {
jerry_value_t jmode =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE);
if (jerry_value_is_undefined(jmode)) {
spi->mode = kSpiMode_0;
} else {
if (jerry_value_is_number(jmode)) {
spi->mode = (SpiMode)iotjs_jval_as_number(jmode);
} else {
spi->mode = __kSpiModeMax;
}
if (spi->mode >= __kSpiModeMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - mode should be MODE[0], [1], [2] or [3]");
}
}
jerry_release_value(jmode);
jerry_value_t jchip_select =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT);
if (jerry_value_is_undefined(jchip_select)) {
spi->chip_select = kSpiCsNone;
} else {
if (jerry_value_is_number(jchip_select)) {
spi->chip_select = (SpiChipSelect)iotjs_jval_as_number(jchip_select);
} else {
spi->chip_select = __kSpiCsMax;
}
if (spi->chip_select >= __kSpiCsMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - chipSelect should be CHIPSELECT.NONE or HIGH");
}
}
jerry_release_value(jchip_select);
jerry_value_t jmax_speed =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED);
if (jerry_value_is_undefined(jmax_speed)) {
spi->max_speed = 500000;
} else {
if (!jerry_value_is_number(jmax_speed)) {
return JS_CREATE_ERROR(TYPE, "Bad arguments - maxSpeed should be Number");
}
spi->max_speed = iotjs_jval_as_number(jmax_speed);
}
jerry_release_value(jmax_speed);
jerry_value_t jbits_per_word =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD);
if (jerry_value_is_undefined(jbits_per_word)) {
spi->bits_per_word = 8;
} else {
if (jerry_value_is_number(jbits_per_word)) {
spi->bits_per_word = iotjs_jval_as_number(jbits_per_word);
} else {
spi->bits_per_word = 0;
}
if (spi->bits_per_word != 8 && spi->bits_per_word != 9) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - bitsPerWord should be 8 or 9");
}
}
jerry_release_value(jbits_per_word);
jerry_value_t jbit_order =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER);
if (jerry_value_is_undefined(jbit_order)) {
spi->bit_order = kSpiOrderMsb;
} else {
if (jerry_value_is_number(jbit_order)) {
spi->bit_order = (SpiOrder)iotjs_jval_as_number(jbit_order);
} else {
spi->bit_order = __kSpiOrderMax;
}
if (spi->bit_order >= __kSpiOrderMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - bitOrder should be BITORDER.MSB or LSB");
}
}
jerry_release_value(jbit_order);
jerry_value_t jloopback =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK);
if (jerry_value_is_undefined(jloopback)) {
spi->loopback = false;
} else {
if (!jerry_value_is_boolean(jloopback)) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - loopback should be Boolean");
}
spi->loopback = iotjs_jval_as_boolean(jloopback);
}
jerry_release_value(jloopback);
return jerry_create_undefined();
}
