int main(int argc, char *argv[])
{
DBusConnection *conn;
struct ADAPTER_PROPERTIES *p;
conn = init_dbus();
p = (struct ADAPTER_PROPERTIES *)malloc(sizeof(struct ADAPTER_PROPERTIES));
p->DiscoverableTimeout = 0;
p->PairableTimeout = 0;
p->Pairable = true;
p->Discoverable = true;
set_property(conn, "DiscoverableTimeout", p);
set_property(conn, "PairableTimeout", p);
set_property(conn, "Pairable", p);
set_property(conn, "Discoverable", p);
free(p);
get_properties(conn);
printf("%s %d\n", __func__, __LINE__);
start_discovery(conn);
printf("%s %d\n", __func__, __LINE__);
return 0;
}
static void cmd_poll(void)
{
printf("#####################################\n");
printf("## NFC demo through Neardal ##\n");
printf("#####################################\n");
if (create_loop(&main_loop) != NEARDAL_SUCCESS) return;
do
{
main_loop_state = wait;
/* Start discovery Loop */
if (start_discovery(NEARD_ADP_MODE_DUAL) != NEARDAL_SUCCESS) return;
printf("---- Waiting for a Tag/Device");
/* Start a thread to get keystroke */
if (start_thread(&wait_for_keystroke) != NEARDAL_SUCCESS) return;
/* Wait for tag/device lost to restart the discovery or for keystroke to leave */
g_timeout_add (100 , wait_lost , main_loop);
g_main_loop_run(main_loop);
/* loop until keystroke */
} while (main_loop_state != keystroke);
g_main_loop_unref(main_loop);
neardal_stop_poll(AdpName);
printf("Leaving ...\n");
}
/**
* gssdp_resource_browser_rescan:
* @resource_browser: A #GSSDPResourceBrowser
*
* Begins discovery if @resource_browser is active and no discovery is
* performed. Otherwise does nothing.
*
* Return value: %TRUE if rescaning has been started.
**/
gboolean
gssdp_resource_browser_rescan (GSSDPResourceBrowser *resource_browser)
{
GSSDPResourceBrowserPrivate *priv;
g_return_val_if_fail (GSSDP_IS_RESOURCE_BROWSER (resource_browser), 0);
priv = gssdp_resource_browser_get_instance_private (resource_browser);
if (priv->active &&
priv->timeout_src == NULL &&
priv->refresh_cache_src == NULL) {
start_discovery (resource_browser);
return TRUE;
}
return FALSE;
}
/**
* gssdp_resource_browser_set_active:
* @resource_browser: A #GSSDPResourceBrowser
* @active: %TRUE to activate @resource_browser
*
* (De)activates @resource_browser.
**/
void
gssdp_resource_browser_set_active (GSSDPResourceBrowser *resource_browser,
gboolean active)
{
GSSDPResourceBrowserPrivate *priv;
g_return_if_fail (GSSDP_IS_RESOURCE_BROWSER (resource_browser));
priv = gssdp_resource_browser_get_instance_private (resource_browser);
if (priv->active == active)
return;
priv->active = active;
if (active) {
start_discovery (resource_browser);
} else {
stop_discovery (resource_browser);
clear_cache (resource_browser);
}
g_object_notify (G_OBJECT (resource_browser), "active");
}
static void handle_getcapabilities_req(struct unix_client *client,
struct bt_get_capabilities_req *req)
{
struct audio_device *dev;
bdaddr_t src, dst;
int err = EIO;
const char *interface;
if (!check_nul(req->source) || !check_nul(req->destination) ||
!check_nul(req->object)) {
err = EINVAL;
goto failed;
}
str2ba(req->source, &src);
str2ba(req->destination, &dst);
if (!manager_find_device(req->object, &src, &dst, NULL, FALSE))
goto failed;
if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO)
interface = AUDIO_HEADSET_INTERFACE;
else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP)
interface = AUDIO_SINK_INTERFACE;
else
interface = client->interface;
dev = manager_find_device(req->object, &src, &dst, interface, TRUE);
if (!dev && (req->flags & BT_FLAG_AUTOCONNECT))
dev = manager_find_device(req->object, &src, &dst,
interface, FALSE);
if (!dev) {
if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO)
interface = AUDIO_GATEWAY_INTERFACE;
else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP)
interface = AUDIO_SOURCE_INTERFACE;
else
interface = NULL;
dev = manager_find_device(req->object, &src, &dst,
interface, TRUE);
if (!dev && (req->flags & BT_FLAG_AUTOCONNECT))
dev = manager_find_device(req->object, &src, &dst,
interface, FALSE);
}
if (!dev) {
error("Unable to find a matching device");
goto failed;
}
client->type = select_service(dev, interface);
if (client->type == TYPE_NONE) {
error("No matching service found");
goto failed;
}
if (g_strcmp0(interface, client->interface) != 0) {
g_free(client->interface);
client->interface = g_strdup(interface);
}
client->seid = req->seid;
start_discovery(dev, client);
return;
failed:
unix_ipc_error(client, BT_GET_CAPABILITIES, err);
}
void tester_handle_gap(uint8_t opcode, uint8_t index, uint8_t *data,
uint16_t len)
{
switch (opcode) {
case GAP_READ_SUPPORTED_COMMANDS:
case GAP_READ_CONTROLLER_INDEX_LIST:
if (index != BTP_INDEX_NONE){
tester_rsp(BTP_SERVICE_ID_GAP, opcode, index,
BTP_STATUS_FAILED);
return;
}
break;
default:
if (index != CONTROLLER_INDEX){
tester_rsp(BTP_SERVICE_ID_GAP, opcode, index,
BTP_STATUS_FAILED);
return;
}
break;
}
switch (opcode) {
case GAP_READ_SUPPORTED_COMMANDS:
supported_commands(data, len);
return;
case GAP_READ_CONTROLLER_INDEX_LIST:
controller_index_list(data, len);
return;
case GAP_READ_CONTROLLER_INFO:
controller_info(data, len);
return;
case GAP_SET_CONNECTABLE:
set_connectable(data, len);
return;
case GAP_SET_DISCOVERABLE:
set_discoverable(data, len);
return;
case GAP_START_ADVERTISING:
start_advertising(data, len);
return;
case GAP_STOP_ADVERTISING:
stop_advertising(data, len);
return;
case GAP_START_DISCOVERY:
start_discovery(data, len);
return;
case GAP_STOP_DISCOVERY:
stop_discovery(data, len);
return;
case GAP_CONNECT:
connect(data, len);
return;
case GAP_DISCONNECT:
disconnect(data, len);
return;
case GAP_SET_IO_CAP:
set_io_cap(data, len);
return;
case GAP_PAIR:
pair(data, len);
return;
case GAP_PASSKEY_ENTRY:
passkey_entry(data, len);
return;
default:
tester_rsp(BTP_SERVICE_ID_GAP, opcode, index,
BTP_STATUS_UNKNOWN_CMD);
return;
}
}
static void cmd_push(int argc, char *argv[])
{
errorCode_t ec = NEARDAL_SUCCESS;
memset(&rcd, 0, sizeof(neardal_record));
if (argc > 2) {
/* Parse options */
ec = cmd_prv_parseOptions(&argc, &argv, options);
} else
ec = NEARDAL_ERROR_INVALID_PARAMETER;
if (ec != NEARDAL_SUCCESS)
{
printf("\nexample of use: demo push -t URI -u http://www.nxp.com");
printf("\n<demo push -h> for more help\n");
}
else
{
if (create_loop(&main_loop) != NEARDAL_SUCCESS) return;
main_loop_state = wait;
printf("---- Waiting for a Device to push");
/* Start a thread to get keystroke */
if (start_thread(&wait_for_keystroke) != NEARDAL_SUCCESS) return;
while (1)
{
/* Start discovery Loop */
if (start_discovery(NEARD_ADP_MODE_DUAL) != NEARDAL_SUCCESS) return;
/* Wait for tag/device found or for keystroke */
main_loop_state = wait;
g_timeout_add (100, wait_found, main_loop);
g_main_loop_run(main_loop);
if (main_loop_state == device_found)
{
/* Device found, push data */
rcd.name=DevName;
if (neardal_dev_push(&rcd) != NEARDAL_SUCCESS)
printf("\t---- Failed to push !!!\n");
else
printf("\t---- Push sucessful !\n");
break;
}
else if (main_loop_state == tag_found)
{
/* Tag found, wait for tag lost before restarting */
g_timeout_add (100 , wait_lost , main_loop);
g_main_loop_run(main_loop);
if (main_loop_state == keystroke)
{
printf("Leaving ...\n");
break;
}
}
else
{
/* Stop Discovery Loop*/
neardal_stop_poll(AdpName);
break;
}
}
main_loop_state = keystroke;
g_timeout_add (100, wait_lost, main_loop);
g_main_loop_run(main_loop);
g_main_loop_unref(main_loop);
}
free_record(rcd);
printf("Leaving ...\n");
}
static void cmd_write(int argc, char *argv[])
{
errorCode_t ec = NEARDAL_SUCCESS;
memset(&rcd, 0, sizeof(neardal_record));
if (argc > 2) {
/* Parse options */
ec = cmd_prv_parseOptions(&argc, &argv, options);
} else
ec = NEARDAL_ERROR_INVALID_PARAMETER;
if (ec != NEARDAL_SUCCESS)
{
printf("\nexample of use: demo write -t Text -l en -e UTF-8 -r \"Test\"");
printf("\n<demo write -h> for more help\n");
}
else
{
if (create_loop(&main_loop) != NEARDAL_SUCCESS) return;
printf("---- Waiting for a Tag to write");
/* Start a thread to get keystroke */
if (start_thread(&wait_for_keystroke) != NEARDAL_SUCCESS) return;
while (1)
{
/* Start discovery Loop */
if (start_discovery(NEARD_ADP_MODE_INITIATOR) != NEARDAL_SUCCESS) return;
/* Wait for tag/device found or for keystroke */
main_loop_state = wait;
g_timeout_add (100, wait_found, main_loop);
g_main_loop_run(main_loop);
if (main_loop_state == tag_found)
{
/* Tag found, write data */
rcd.name=TagName;
sleep(1);//workaround crash neard
if (neardal_tag_write(&rcd) != NEARDAL_SUCCESS)
printf("\t---- Failed to write !!!\n");
else
printf("\t---- Write sucessful !\n");
break;
}
else if (main_loop_state == device_found)
{
/* Device found, wait for Device lost before restarting */
g_timeout_add (100 , wait_lost , main_loop);
g_main_loop_run(main_loop);
if (main_loop_state == keystroke)
{
printf("Leaving ...\n");
break;
}
}
else if (main_loop_state == tag_lost)
{
printf("\t---- Failed to write\n");
break;
}
else
{
/* Stop Discovery Loop*/
neardal_stop_poll(AdpName);
break;
}
}
main_loop_state = keystroke;
g_timeout_add (100, wait_lost, main_loop);
g_main_loop_run(main_loop);
g_main_loop_unref(main_loop);
}
free_record(rcd);
printf("Leaving ...\n");
}
