void Transfer::setState(State newState)
{
bool now,was = isActive();
m_lastState = m_state;
if(newState == m_lastState)
return;
enterLogMessage(tr("Changed state: %1 -> %2").arg(state2string(m_state)).arg(state2string(newState)));
m_state = newState;
now = isActive();
if(now != was)
{
m_bWorking = false;
changeActive(now);
if(now)
m_timeStart = QDateTime::currentDateTime();
else
m_nTimeRunning += m_timeStart.secsTo(QDateTime::currentDateTime());
}
if(!m_bLocal)
emit stateChanged(m_state, newState);
}
static void
player_state_changed_cb (GstElement * recorder, KmsUriEndpointState newState,
gpointer loop)
{
GST_INFO ("Element %s changed its state to %s.", GST_ELEMENT_NAME (recorder),
state2string (newState));
}
// Prints out the data in the Counts
void print_counts(Counts &data, std::ostream &s) {
unsigned int i;
State sta;
std::string str;
create_state(sta, data.nspecies, data.nalpha);
s << "species: ";
for (i=0; i < data.species.size(); i++) {
s << data.species[i] << " ";
}
s << std::endl;
s << "nalpha: " << data.nalpha << std::endl;
s << "nspecies: " << data.nspecies << std::endl;
s << "nstates: " << data.nstates << std::endl;
s << "total: " << data.N << std::endl;
s << "counts: " << std::endl;
for (i=0; i < data.c.size(); i++) {
if (data.c[i] > 0) {
index2state(i, sta);
state2string(sta, str);
s << " " << str << ": " << data.c[i] << std::endl;
}
}
s << std::endl;
}
static void
state_changed_cb2 (GstElement * recorder, KmsUriEndpointState newState,
gpointer loop)
{
GST_DEBUG ("State changed %s.", state2string (newState));
if (newState == KMS_URI_ENDPOINT_STATE_STOP)
g_idle_add (quit_main_loop_idle, loop);
}
static void
recorder_state_changed_cb (GstElement * recorder, KmsUriEndpointState newState,
gpointer loop)
{
GST_INFO ("Element %s changed its state to %s.", GST_ELEMENT_NAME (recorder),
state2string (newState));
if (newState == KMS_URI_ENDPOINT_STATE_STOP)
g_main_loop_quit (loop);
}
static void
state_changed_cb (GstElement * recorder, KmsUriEndpointState newState,
gpointer loop)
{
const struct state_controller *transitions = get_transtions ();
guint seconds = transitions[state].seconds;
GST_DEBUG ("State changed %s. Time %d seconds.", state2string (newState),
seconds);
g_timeout_add (seconds * 1000, transite_cb, loop);
}
static void state_changed(struct connman_technology *technology)
{
const char *str;
str = state2string(technology->state);
if (str == NULL)
return;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "State",
DBUS_TYPE_STRING, &str);
}
static void state_changed(struct connman_peer *peer)
{
const char *state;
state = state2string(peer->state);
if (!state || !allow_property_changed(peer))
return;
connman_dbus_property_changed_basic(peer->path,
CONNMAN_PEER_INTERFACE, "State",
DBUS_TYPE_STRING, &state);
}
static DBusMessage *get_properties(DBusConnection *conn,
DBusMessage *message, void *user_data)
{
struct connman_technology *technology = user_data;
DBusMessage *reply;
DBusMessageIter array, dict;
const char *str;
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
connman_dbus_dict_open(&array, &dict);
str = state2string(technology->state);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &str);
str = get_name(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
if (str != NULL)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
&technology->tethering);
if (technology->tethering_ident != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
if (technology->tethering_passphrase != NULL)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
connman_dbus_dict_close(&array, &dict);
return reply;
}
/**
* \brief Get command implementation
*/
int command_get(MountPrx mount) {
RaDec radec = mount->getRaDec();
astro::Angle ra;
ra.hours(radec.ra);
astro::Angle dec;
dec.degrees(radec.dec);
if (decimal) {
std::cout << ra.hms() << " " << dec.dms() << " ";
} else {
std::cout << ra.hours() << " " << dec.degrees() << " ";
}
std::cout << state2string(mount->state());
std::cout << std::endl;
return EXIT_SUCCESS;
}
static void
state_changed_cb3 (GstElement * recorder, KmsUriEndpointState newState,
gpointer loop)
{
GST_DEBUG ("State changed %s.", state2string (newState));
if (newState == KMS_URI_ENDPOINT_STATE_START) {
if (RUNNING_ON_VALGRIND) {
g_timeout_add (15000, stop_recorder, NULL);
} else {
g_timeout_add (3000, stop_recorder, NULL);
}
} else if (newState == KMS_URI_ENDPOINT_STATE_STOP) {
g_idle_add (quit_main_loop_idle, loop);
}
}
static void append_properties(DBusMessageIter *iter, struct connman_peer *peer)
{
const char *state = state2string(peer->state);
DBusMessageIter dict;
connman_dbus_dict_open(iter, &dict);
connman_dbus_dict_append_basic(&dict, "State",
DBUS_TYPE_STRING, &state);
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &peer->name);
connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4, peer);
connman_dbus_dict_append_array(&dict, "Services",
DBUS_TYPE_DICT_ENTRY,
append_peer_services, peer);
connman_dbus_dict_close(iter, &dict);
}
static void update_session_state(struct connman_session *session)
{
enum connman_service_state service_state;
enum connman_session_state state = CONNMAN_SESSION_STATE_DISCONNECTED;
if (session->service) {
service_state = __connman_service_get_state(session->service);
state = service_to_session_state(service_state);
session->info->state = state;
}
session->info->state = state;
DBG("session %p state %s", session, state2string(state));
update_routing_table(session);
update_nat_rules(session);
session_notify(session);
}
/**
* \brief Implementation of the get command
*/
int get_command(MountPtr mount) {
RaDec radec = mount->getRaDec();
if (decimal) {
std::cout << radec.ra().hours();
std::cout << " ";
if (radec.dec() > Angle(M_PI)) {
std::cout << (radec.dec() - Angle(2 * M_PI)).degrees();
} else {
std::cout << radec.dec().degrees();
}
} else {
std::cout << radec.ra().hms();
std::cout << " ";
if (radec.dec() > Angle(M_PI)) {
std::cout << (radec.dec() - Angle(2 * M_PI)).dms();
} else {
std::cout << radec.dec().dms();
}
}
std::cout << " ";
std::cout << state2string(mount->state());
std::cout << std::endl;
return EXIT_SUCCESS;
}
static void
change_state (KmsUriEndpointState state)
{
GstElement *testsrc;
GstElement *testsink;
GST_DEBUG ("Setting recorder to state %s", state2string (state));
g_object_set (G_OBJECT (recorder), "state", state, NULL);
/* Add more element to the pipeline to check that this does not affect
to the timestamps */
testsrc = gst_element_factory_make ("videotestsrc", NULL);
testsink = gst_element_factory_make ("fakesink", NULL);
g_object_set (testsink, "async", FALSE, "sync", FALSE, NULL);
g_object_set (testsrc, "is-live", TRUE, NULL);
GST_DEBUG_OBJECT (recorder, "Adding more elements");
gst_bin_add_many (GST_BIN (GST_OBJECT_PARENT (recorder)), testsrc, testsink,
NULL);
gst_element_link (testsrc, testsink);
gst_element_sync_state_with_parent (testsink);
gst_element_sync_state_with_parent (testsrc);
}
static void append_notify(DBusMessageIter *dict,
struct connman_session *session)
{
struct session_info *info = session->info;
struct session_info *info_last = session->info_last;
struct connman_service *service;
enum connman_service_type type;
const char *name, *bearer;
char *ifname;
int idx;
if (session->append_all || info->state != info_last->state) {
const char *state = state2string(info->state);
connman_dbus_dict_append_basic(dict, "State",
DBUS_TYPE_STRING,
&state);
info_last->state = info->state;
}
if (session->append_all || session->service != session->service_last) {
if (session->service) {
service = session->service;
name = __connman_service_get_name(service);
idx = __connman_service_get_index(service);
ifname = connman_inet_ifname(idx);
if (!ifname)
ifname = g_strdup("");
type = connman_service_get_type(service);
bearer = service2bearer(type);
} else {
service = NULL;
name = "";
ifname = g_strdup("");
bearer = "";
}
connman_dbus_dict_append_basic(dict, "Name",
DBUS_TYPE_STRING,
&name);
connman_dbus_dict_append_dict(dict, "IPv4",
append_ipconfig_ipv4,
service);
connman_dbus_dict_append_dict(dict, "IPv6",
append_ipconfig_ipv6,
service);
connman_dbus_dict_append_basic(dict, "Interface",
DBUS_TYPE_STRING,
&ifname);
connman_dbus_dict_append_basic(dict, "Bearer",
DBUS_TYPE_STRING,
&bearer);
g_free(ifname);
session->service_last = session->service;
}
if (session->append_all ||
info->config.type != info_last->config.type) {
const char *type = type2string(info->config.type);
connman_dbus_dict_append_basic(dict, "ConnectionType",
DBUS_TYPE_STRING,
&type);
info_last->config.type = info->config.type;
}
if (session->append_all ||
info->config.allowed_bearers != info_last->config.allowed_bearers) {
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
info_last->config.allowed_bearers = info->config.allowed_bearers;
}
session->append_all = false;
}
static void
change_state (KmsUriEndpointState state)
{
GST_DEBUG ("Setting recorder to state %s", state2string (state));
g_object_set (G_OBJECT (recorder), "state", state, NULL);
}
static void append_notify(DBusMessageIter *dict,
struct connman_session *session)
{
struct session_info *info = session->info;
struct session_info *info_last = session->info_last;
struct connman_service *service;
const char *name, *ifname, *bearer;
if (session->append_all == TRUE ||
info->state != info_last->state) {
const char *state = state2string(info->state);
connman_dbus_dict_append_basic(dict, "State",
DBUS_TYPE_STRING,
&state);
info_last->state = info->state;
}
if (session->append_all == TRUE ||
info->entry != info_last->entry) {
if (info->entry == NULL) {
name = "";
ifname = "";
service = NULL;
bearer = "";
} else {
name = info->entry->name;
ifname = info->entry->ifname;
service = info->entry->service;
bearer = info->entry->bearer;
}
connman_dbus_dict_append_basic(dict, "Name",
DBUS_TYPE_STRING,
&name);
connman_dbus_dict_append_dict(dict, "IPv4",
append_ipconfig_ipv4,
service);
connman_dbus_dict_append_dict(dict, "IPv6",
append_ipconfig_ipv6,
service);
connman_dbus_dict_append_basic(dict, "Interface",
DBUS_TYPE_STRING,
&ifname);
connman_dbus_dict_append_basic(dict, "Bearer",
DBUS_TYPE_STRING,
&bearer);
info_last->entry = info->entry;
}
if (session->append_all == TRUE ||
info->config.type != info_last->config.type) {
const char *type = type2string(info->config.type);
connman_dbus_dict_append_basic(dict, "ConnectionType",
DBUS_TYPE_STRING,
&type);
info_last->config.type = info->config.type;
}
if (session->append_all == TRUE ||
info->config.allowed_bearers != info_last->config.allowed_bearers) {
connman_dbus_dict_append_array(dict, "AllowedBearers",
DBUS_TYPE_STRING,
append_allowed_bearers,
info);
info_last->config.allowed_bearers = info->config.allowed_bearers;
}
session->append_all = FALSE;
}
CcdState::State QsiCcd::exposureStatus() {
std::unique_lock<std::recursive_mutex> lock(_camera.mutex);
debug(LOG_DEBUG, DEBUG_LOG, 0, "checking camera state");
QSICamera::CameraState qsistate;
_camera.camera().get_CameraState(&qsistate);
debug(LOG_DEBUG, DEBUG_LOG, 0, "qsistate = %s",
state2string(qsistate).c_str());
switch (state()) {
case CcdState::idle:
switch (qsistate) {
case QSICamera::CameraIdle:
break;
case QSICamera::CameraWaiting:
case QSICamera::CameraExposing:
state(CcdState::exposing);
break;
case QSICamera::CameraReading:
case QSICamera::CameraDownload:
debug(LOG_DEBUG, DEBUG_LOG, 0, "turn LED on");
_camera.camera().put_LEDEnabled(true);
state(CcdState::exposed);
break;
case QSICamera::CameraError:
break;
}
break;
case CcdState::exposing:
switch (qsistate) {
case QSICamera::CameraIdle:
case QSICamera::CameraWaiting:
state(CcdState::exposed);
break;
case QSICamera::CameraExposing:
state(CcdState::exposing);
break;
case QSICamera::CameraReading:
case QSICamera::CameraDownload:
debug(LOG_DEBUG, DEBUG_LOG, 0, "turn LED on");
_camera.camera().put_LEDEnabled(true);
state(CcdState::exposed);
break;
case QSICamera::CameraError:
break;
}
break;
case CcdState::exposed:
switch (qsistate) {
case QSICamera::CameraIdle:
case QSICamera::CameraWaiting:
case QSICamera::CameraExposing:
case QSICamera::CameraReading:
case QSICamera::CameraDownload:
case QSICamera::CameraError:
break;
}
break;
case CcdState::cancelling:
switch (qsistate) {
case QSICamera::CameraIdle:
state(CcdState::idle);
break;
case QSICamera::CameraWaiting:
break;
case QSICamera::CameraExposing:
case QSICamera::CameraReading:
case QSICamera::CameraDownload:
state(CcdState::exposing);
break;
case QSICamera::CameraError:
break;
}
break;
}
debug(LOG_DEBUG, DEBUG_LOG, 0, "new state %s",
CcdState::state2string(state()).c_str());
return state();
}
