void supla_client_set_registered(void *_suplaclient, char registered) {
TSuplaClientData *scd = (TSuplaClientData*)_suplaclient;
lck_lock(scd->lck);
scd->registered = registered;
lck_unlock(scd->lck);
}
void SRPC_ICACHE_FLASH srpc_set_proto_version(void *_srpc, unsigned char version) {
Tsrpc *srpc = (Tsrpc*)_srpc;
lck_lock(srpc->lck);
sproto_set_version(srpc->proto, version);
lck_unlock(srpc->lck);
}
int supla_client_locations::count() {
int result = 0;
lck_lock(lck);
result = ids_count;
lck_unlock(lck);
return result;
}
char supla_client_registered(void *_suplaclient) {
TSuplaClientData *scd = (TSuplaClientData*)_suplaclient;
char result;
lck_lock(scd->lck);
result = scd->registered;
lck_unlock(scd->lck);
return result;
}
void supla_client_locations::ids_clean(void) {
lck_lock(lck);
if ( ids )
free(ids);
ids_count = 0;
lck_unlock(lck);
}
unsigned char SRPC_ICACHE_FLASH srpc_get_proto_version(void *_srpc) {
unsigned char version;
Tsrpc *srpc = (Tsrpc*)_srpc;
lck_lock(srpc->lck);
version = sproto_get_version(srpc->proto);
lck_unlock(srpc->lck);
return version;
}
int supla_client::getName(char *buffer, int size) {
if (size < 1) return 0;
buffer[0] = 0;
lck_lock(lck);
snprintf(buffer, size, "%s", this->name);
lck_unlock(lck);
buffer[size - 1] = 0;
return strnlen(buffer, size - 1);
}
bool supla_client_locations::location_exists(int Id) {
bool result = false;
lck_lock(lck);
for(int a=0;a<ids_count;a++)
if ( ids[a] == Id ) {
result = true;
break;
}
lck_unlock(lck);
return result;
}
char supla_client_open(void *_suplaclient, int ChannelID, char open) {
TCS_SuplaChannelNewValue_B value;
TSuplaClientData *suplaclient = (TSuplaClientData *)_suplaclient;
char result = 0;
lck_lock(suplaclient->lck);
if ( supla_client_registered(_suplaclient) == 1 ) {
memset(&value, 0, sizeof(TCS_SuplaChannelNewValue_B));
value.ChannelId = ChannelID;
value.value[0] = open;
result = srpc_cs_async_set_channel_value_b(suplaclient->srpc, &value) == SUPLA_RESULT_FALSE ? 0 : 1;
}
lck_unlock(suplaclient->lck);
return result;
}
void supla_client_locations::load(int ClientID) {
database *db = new database();
int a, n;
if ( db->connect() == true ) {
safe_array_lock(arr);
arr_clean();
db->get_client_locations(ClientID, this);
lck_lock(lck);
ids_clean();
n = safe_array_count(arr);
if ( n > 0 ) {
ids = (int*)malloc(sizeof(int)*n);
}
if ( ids )
for(a=0;a<n;a++) {
supla_client_location *loc = (supla_client_location *)safe_array_get(arr, a);
if ( loc != NULL ) {
ids[ids_count] = loc->getId();
ids_count++;
}
}
lck_unlock(lck);
safe_array_unlock(arr);
}
delete db;
}
int lck_unlock_r(void *lck, int result) {
#ifndef __SINGLE_THREAD
lck_unlock(lck);
#endif /*__SINGLE_THREAD*/
return result;
}
void supla_client::setName(const char *name) {
lck_lock(lck);
snprintf(this->name, SUPLA_CLIENT_NAME_MAXSIZE, "%s", name);
this->name[SUPLA_CLIENT_NAME_MAXSIZE - 1] = 0;
lck_unlock(lck);
}
char SRPC_ICACHE_FLASH srpc_iterate(void *_srpc) {
Tsrpc *srpc = (Tsrpc*)_srpc;
char data_buffer[srpc_BUFFER_SIZE];
char result;
unsigned char version;
// --------- IN ---------------
_supla_int_t data_size = srpc->params.data_read(data_buffer, srpc_BUFFER_SIZE, srpc->params.user_params);
if ( data_size == 0 )
return SUPLA_RESULT_FALSE;
lck_lock(srpc->lck);
if ( data_size > 0
&& SUPLA_RESULT_TRUE != ( result = sproto_in_buffer_append(srpc->proto, data_buffer, data_size) ) ) {
supla_log(LOG_DEBUG, "sproto_in_buffer_append: %i, datasize: %i", result, data_size);
return lck_unlock_r(srpc->lck, SUPLA_RESULT_FALSE);
}
if ( SUPLA_RESULT_TRUE == (result = sproto_pop_in_sdp(srpc->proto, &srpc->sdp) ) ) {
if ( SUPLA_RESULT_TRUE == srpc_in_queue_push(srpc, &srpc->sdp) ) {
if ( srpc->params.on_remote_call_received ) {
lck_unlock(srpc->lck);
srpc->params.on_remote_call_received(srpc, srpc->sdp.rr_id, srpc->sdp.call_type, srpc->params.user_params, srpc->sdp.version);
lck_lock(srpc->lck);
}
} else {
supla_log(LOG_DEBUG, "ssrpc_in_queue_push error");
return lck_unlock_r(srpc->lck, SUPLA_RESULT_FALSE);
}
} else if ( result != SUPLA_RESULT_FALSE ) {
if ( result == SUPLA_RESULT_VERSION_ERROR ) {
if ( srpc->params.on_version_error ) {
version = srpc->sdp.version;
lck_unlock(srpc->lck);
srpc->params.on_version_error(srpc, version, srpc->params.user_params);
return SUPLA_RESULT_FALSE;
}
} else {
supla_log(LOG_DEBUG, "sproto_pop_in_sdp error: %i", result);
}
return lck_unlock_r(srpc->lck, SUPLA_RESULT_FALSE);
}
// --------- OUT ---------------
if ( srpc_out_queue_pop(srpc, &srpc->sdp, 0) == SUPLA_RESULT_TRUE
&& SUPLA_RESULT_TRUE != (result = sproto_out_buffer_append(srpc->proto, &srpc->sdp) )
&& result != SUPLA_RESULT_FALSE ) {
supla_log(LOG_DEBUG, "sproto_out_buffer_append error: %i", result);
return lck_unlock_r(srpc->lck, SUPLA_RESULT_FALSE);
}
data_size = sproto_pop_out_data(srpc->proto, data_buffer, srpc_BUFFER_SIZE);
if ( data_size != 0 ) {
lck_unlock(srpc->lck);
srpc->params.data_write(data_buffer, data_size, srpc->params.user_params);
lck_lock(srpc->lck);
#ifndef __EH_DISABLED
if ( srpc->params.eh != 0
&& sproto_out_dataexists(srpc->proto) == 1 ) {
eh_raise_event(srpc->params.eh);
}
#endif
}
return lck_unlock_r(srpc->lck, SUPLA_RESULT_TRUE);
}