static void device_sink_cb(struct audio_device *dev,
sink_state_t old_state,
sink_state_t new_state,
void *user_data)
{
struct dev_priv *priv = dev->priv;
if (!dev->sink)
return;
priv->sink_state = new_state;
switch (new_state) {
case SINK_STATE_DISCONNECTED:
if (dev->control) {
device_remove_control_timer(dev);
avrcp_disconnect(dev);
}
device_set_state(dev, AUDIO_STATE_DISCONNECTED);
break;
case SINK_STATE_CONNECTING:
device_remove_avdtp_timer(dev);
device_set_state(dev, AUDIO_STATE_CONNECTING);
break;
case SINK_STATE_CONNECTED:
if (old_state == SINK_STATE_PLAYING)
break;
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case SINK_STATE_PLAYING:
break;
}
}
static void
check_addresses (NMIP6Device *device)
{
NMIP6Manager *manager = device->manager;
NMIP6ManagerPrivate *priv = NM_IP6_MANAGER_GET_PRIVATE (manager);
struct rtnl_addr *rtnladdr;
struct nl_addr *nladdr;
struct in6_addr *addr;
/* Reset address information */
device->has_linklocal = FALSE;
device->has_nonlinklocal = FALSE;
/* Look for any IPv6 addresses the kernel may have set for the device */
for (rtnladdr = (struct rtnl_addr *) nl_cache_get_first (priv->addr_cache);
rtnladdr;
rtnladdr = (struct rtnl_addr *) nl_cache_get_next ((struct nl_object *) rtnladdr)) {
char buf[INET6_ADDRSTRLEN];
if (rtnl_addr_get_ifindex (rtnladdr) != device->ifindex)
continue;
nladdr = rtnl_addr_get_local (rtnladdr);
if (!nladdr || nl_addr_get_family (nladdr) != AF_INET6)
continue;
addr = nl_addr_get_binary_addr (nladdr);
if (inet_ntop (AF_INET6, addr, buf, INET6_ADDRSTRLEN) > 0) {
nm_log_dbg (LOGD_IP6, "(%s): netlink address: %s/%d",
device->iface, buf,
rtnl_addr_get_prefixlen (rtnladdr));
}
if (IN6_IS_ADDR_LINKLOCAL (addr)) {
if (device->state == NM_IP6_DEVICE_UNCONFIGURED)
device_set_state (device, NM_IP6_DEVICE_GOT_LINK_LOCAL);
device->has_linklocal = TRUE;
} else {
if (device->state == NM_IP6_DEVICE_GOT_ROUTER_ADVERTISEMENT)
device_set_state (device, NM_IP6_DEVICE_GOT_ADDRESS);
device->has_nonlinklocal = TRUE;
}
}
/* There might be a LL address hanging around on the interface from
* before in the initial run, but if it goes away later, make sure we
* regress from GOT_LINK_LOCAL back to UNCONFIGURED.
*/
if ((device->state == NM_IP6_DEVICE_GOT_LINK_LOCAL) && !device->has_linklocal)
device_set_state (device, NM_IP6_DEVICE_UNCONFIGURED);
nm_log_dbg (LOGD_IP6, "(%s): addresses checked (state %s)",
device->iface, state_to_string (device->state));
}
static int device_coldplug(Unit *u) {
Device *d = DEVICE(u);
assert(d);
assert(d->state == DEVICE_DEAD);
if (d->found & DEVICE_FOUND_UDEV)
/* If udev says the device is around, it's around */
device_set_state(d, DEVICE_PLUGGED);
else if (d->found != DEVICE_NOT_FOUND && d->deserialized_state != DEVICE_PLUGGED)
/* If a device is found in /proc/self/mountinfo or
* /proc/swaps, and was not yet announced via udev,
* it's "tentatively" around. */
device_set_state(d, DEVICE_TENTATIVE);
return 0;
}
static int device_coldplug(Unit *u) {
Device *d = DEVICE(u);
assert(d);
assert(d->state == DEVICE_DEAD);
if (d->sysfs)
device_set_state(d, DEVICE_PLUGGED);
return 0;
}
static void device_sink_cb(struct audio_device *dev,
sink_state_t old_state,
sink_state_t new_state,
void *user_data)
{
struct dev_priv *priv = dev->priv;
if (!dev->sink)
return;
priv->sink_state = new_state;
switch (new_state) {
case SINK_STATE_DISCONNECTED:
if (dev->control) {
device_remove_control_timer(dev);
avrcp_disconnect(dev);
}
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_DISCONNECTED);
else if (old_state == SINK_STATE_CONNECTING) {
switch (priv->hs_state) {
case HEADSET_STATE_CONNECTED:
case HEADSET_STATE_PLAY_IN_PROGRESS:
case HEADSET_STATE_PLAYING:
device_set_state(dev, AUDIO_STATE_CONNECTED);
default:
break;
}
}
break;
case SINK_STATE_CONNECTING:
device_remove_avdtp_timer(dev);
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTING);
break;
case SINK_STATE_CONNECTED:
if (old_state == SINK_STATE_PLAYING)
break;
#ifdef ANDROID
/* google code, Broadcom Bluetooth Feature
android_set_high_priority(&dev->dst);
*/
#endif
if (dev->auto_connect) {
if (!dev->headset)
device_set_state(dev, AUDIO_STATE_CONNECTED);
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_headset_timer(dev);
else if (priv->hs_state == HEADSET_STATE_CONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTED);
} else if (priv->hs_state != HEADSET_STATE_CONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case SINK_STATE_PLAYING:
break;
}
}
static void device_sink_cb(struct audio_device *dev,
sink_state_t old_state,
sink_state_t new_state,
void *user_data)
{
struct dev_priv *priv = dev->priv;
if (!dev->sink)
return;
priv->sink_state = new_state;
switch (new_state) {
case SINK_STATE_DISCONNECTED:
if (dev->control) {
device_remove_control_timer(dev);
avrcp_disconnect(dev);
}
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_DISCONNECTED);
else if (old_state == SINK_STATE_CONNECTING) {
switch (priv->hs_state) {
case HEADSET_STATE_CONNECTED:
case HEADSET_STATE_PLAY_IN_PROGRESS:
case HEADSET_STATE_PLAYING:
device_set_state(dev, AUDIO_STATE_CONNECTED);
default:
break;
}
}
break;
case SINK_STATE_CONNECTING:
device_remove_avdtp_timer(dev);
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTING);
break;
case SINK_STATE_CONNECTED:
if (old_state == SINK_STATE_PLAYING)
break;
if (dev->auto_connect) {
if (!dev->headset)
device_set_state(dev, AUDIO_STATE_CONNECTED);
else if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_headset_timer(dev);
else if (priv->hs_state == HEADSET_STATE_CONNECTED ||
priv->hs_state == HEADSET_STATE_PLAY_IN_PROGRESS ||
priv->hs_state == HEADSET_STATE_PLAYING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
} else if (priv->hs_state == HEADSET_STATE_DISCONNECTED ||
priv->hs_state == HEADSET_STATE_CONNECTING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case SINK_STATE_PLAYING:
break;
}
}
static void device_headset_cb(struct audio_device *dev,
headset_state_t old_state,
headset_state_t new_state,
void *user_data)
{
struct dev_priv *priv = dev->priv;
if (!dev->headset)
return;
priv->hs_state = new_state;
switch (new_state) {
case HEADSET_STATE_DISCONNECTED:
device_remove_avdtp_timer(dev);
if (priv->sink_state != SINK_STATE_DISCONNECTED &&
dev->sink && priv->dc_req) {
sink_shutdown(dev->sink);
break;
}
if (priv->sink_state == SINK_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_DISCONNECTED);
else if (old_state == HEADSET_STATE_CONNECTING &&
(priv->sink_state == SINK_STATE_CONNECTED ||
priv->sink_state == SINK_STATE_PLAYING))
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case HEADSET_STATE_CONNECTING:
device_remove_headset_timer(dev);
if (priv->sink_state == SINK_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTING);
break;
case HEADSET_STATE_CONNECTED:
if (old_state == HEADSET_STATE_CONNECTED ||
old_state == HEADSET_STATE_PLAY_IN_PROGRESS ||
old_state == HEADSET_STATE_PLAYING)
break;
if (dev->auto_connect) {
if (!dev->sink)
device_set_state(dev, AUDIO_STATE_CONNECTED);
else if (priv->sink_state == SINK_STATE_DISCONNECTED)
device_set_avdtp_timer(dev);
else if (priv->sink_state == SINK_STATE_CONNECTED ||
priv->sink_state == SINK_STATE_PLAYING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
} else if (priv->sink_state == SINK_STATE_DISCONNECTED ||
priv->sink_state == SINK_STATE_CONNECTING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case HEADSET_STATE_PLAY_IN_PROGRESS:
break;
case HEADSET_STATE_PLAYING:
break;
}
}
static gboolean headset_connect_timeout(gpointer user_data)
{
struct audio_device *dev = user_data;
struct dev_priv *priv = dev->priv;
dev->priv->headset_timer = 0;
if (dev->headset == NULL)
return FALSE;
if (headset_config_stream(dev, FALSE, NULL, NULL) == 0) {
if (priv->state != AUDIO_STATE_CONNECTED &&
(priv->sink_state == SINK_STATE_CONNECTED ||
priv->sink_state == SINK_STATE_PLAYING))
device_set_state(dev, AUDIO_STATE_CONNECTED);
}
return FALSE;
}
static void
check_ra_flags (NMIP6Device *device)
{
device->dhcp_opts = IP6_DHCP_OPT_NONE;
/* We only care about router advertisements if we want a real IPv6 address */
if ( (device->target_state == NM_IP6_DEVICE_GOT_ADDRESS)
&& (device->ra_flags & IF_RA_RCVD)) {
if (device->state < NM_IP6_DEVICE_GOT_ROUTER_ADVERTISEMENT)
device_set_state (device, NM_IP6_DEVICE_GOT_ROUTER_ADVERTISEMENT);
if (device->ra_flags & IF_RA_MANAGED) {
device->dhcp_opts = IP6_DHCP_OPT_MANAGED;
nm_log_dbg (LOGD_IP6, "router advertisement deferred to DHCPv6");
} else if (device->ra_flags & IF_RA_OTHERCONF) {
device->dhcp_opts = IP6_DHCP_OPT_OTHERCONF;
nm_log_dbg (LOGD_IP6, "router advertisement requests parallel DHCPv6");
}
}
nm_log_dbg (LOGD_IP6, "(%s): router advertisement checked (state %s)",
device->iface, state_to_string (device->state));
}
static void device_sink_cb(struct audio_device *dev,
sink_state_t old_state,
sink_state_t new_state,
void *user_data)
{
struct dev_priv *priv = dev->priv;
if (!dev->sink)
return;
priv->sink_state = new_state;
switch (new_state) {
case SINK_STATE_DISCONNECTED:
if (dev->control) {
device_remove_control_timer(dev);
avrcp_disconnect(dev);
}
if (priv->hs_state != HEADSET_STATE_DISCONNECTED &&
priv->dc_req) {
headset_shutdown(dev);
break;
}
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_DISCONNECTED);
else if (old_state == SINK_STATE_CONNECTING) {
switch (priv->hs_state) {
case HEADSET_STATE_CONNECTED:
case HEADSET_STATE_PLAY_IN_PROGRESS:
case HEADSET_STATE_PLAYING:
device_set_state(dev, AUDIO_STATE_CONNECTED);
default:
break;
}
}
break;
case SINK_STATE_CONNECTING:
device_remove_avdtp_timer(dev);
if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_state(dev, AUDIO_STATE_CONNECTING);
break;
case SINK_STATE_CONNECTED:
if (old_state == SINK_STATE_PLAYING)
break;
#ifdef ANDROID
android_set_high_priority(&dev->dst);
#endif
if (dev->auto_connect) {
if (!dev->headset)
device_set_state(dev, AUDIO_STATE_CONNECTED);
else if (priv->hs_state == HEADSET_STATE_DISCONNECTED)
device_set_headset_timer(dev);
else if (priv->hs_state == HEADSET_STATE_CONNECTED ||
priv->hs_state == HEADSET_STATE_PLAY_IN_PROGRESS ||
priv->hs_state == HEADSET_STATE_PLAYING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
} else if (priv->hs_state == HEADSET_STATE_DISCONNECTED ||
priv->hs_state == HEADSET_STATE_CONNECTING)
device_set_state(dev, AUDIO_STATE_CONNECTED);
break;
case SINK_STATE_PLAYING:
//Terry Cheng, 20101222, force to send high priority when playing +
#ifdef ANDROID
//Re-send high priority when playing A2DP. It may not work when only connecting A2DP profile
android_set_high_priority(&dev->dst);
#endif
//Terry Cheng, 20101222, force to send high priority when playing -
break;
}
}
