--- /dev/null
+/*
+ * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <glib.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <geofence_manager.h>
+
+
+/*************** global variable ***************/
+static geofence_manager_h manager;
+static GMainLoop *g_mainloop = NULL;
+static int menu;
+static guint test_timer;
+
+static void geofence_test_cleanup();
+static int geofence_test();
+
+
+/*************** function ***************/
+void show_error(int error)
+{
+ switch (error) {
+ case GEOFENCE_MANAGER_ERROR_NONE:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_NONE\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_OUT_OF_MEMORY:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_OUT_OF_MEMORY\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_NOT_SUPPORTED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_NOT_SUPPORTED\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_INVALID_ID:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_INVALID_ID\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_EXCEPTION:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_EXCEPTION\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_ALREADY_STARTED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_ALREADY_STARTED\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_IPC:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_IPC\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_DATABASE:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_DATABASE\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED\n");
+ break;
+ case GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED:
+ fprintf(stderr, "GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED\n");
+ break;
+ default:
+ fprintf(stderr, "UNKNOWN ERROR\n");
+ break;
+ }
+}
+
+static gboolean exit_program(gpointer data)
+{
+ g_main_loop_quit(g_mainloop);
+ return FALSE;
+}
+
+static gboolean wait_test()
+{
+ if (test_timer) {
+ g_source_remove(test_timer);
+ test_timer = 0;
+ }
+ geofence_test_cleanup();
+ geofence_test();
+
+ return FALSE;
+}
+
+static int scanf_safety(const char *format, ...)
+{
+ char line[256];
+ if (fgets(line, sizeof(line), stdin) == NULL)
+ return -1;
+
+ va_list args;
+ va_start(args, format);
+ int ret = vsscanf(line, format, args);
+ va_end(args);
+
+ return ret;
+}
+
+static bool place_list_cb(int place_id, const char *place_name, int place_index, int place_cnt, void *user_data)
+{
+ if (place_index > place_cnt)
+ return false;
+
+ fprintf(stderr, "Place id: %d, name: %s\n", place_id, place_name);
+ return true;
+}
+
+static bool fence_list_cb(int geofence_id, geofence_h fence, int fence_index, int fence_cnt, void *user_data)
+{
+ if (geofence_id <= 0 || fence_index > fence_cnt)
+ return false;
+
+ int place_id = -1;
+ geofence_type_e type = GEOFENCE_TYPE_GEOPOINT;
+ double latitude = -1.0, longitude = -1.0;
+ int radius = 0;
+ char *address = NULL, *bssid = NULL, *ssid = NULL;
+
+ geofence_get_place_id(fence, &place_id);
+ geofence_get_type(fence, &type);
+ if (type == GEOFENCE_TYPE_GEOPOINT) {
+ geofence_get_latitude(fence, &latitude);
+ geofence_get_longitude(fence, &longitude);
+ geofence_get_radius(fence, &radius);
+ geofence_get_address(fence, &address);
+ fprintf(stderr, "Geofence id: %d, place id: %d, type: %d, latitude: %lf, longitude: %lf, radius: %d, address: %s\n, ", geofence_id, place_id, type, latitude, longitude, radius, address);
+ } else {
+ geofence_get_bssid(fence, &bssid);
+ geofence_get_ssid(fence, &ssid);
+ fprintf(stderr, "Geofence id: %d, place id: %d, type: %d, bssid: %s, ssid: %s\n, ", geofence_id, place_id, type, bssid, ssid);
+ }
+
+ if (address)
+ free(address);
+ if (bssid)
+ free(bssid);
+ if (ssid)
+ free(ssid);
+
+ address = NULL;
+ bssid = NULL;
+ ssid = NULL;
+
+ return true;
+}
+
+static void state_changed_cb(int geofence_id, geofence_state_e state, void *user_data)
+{
+ fprintf(stderr, "Geofence id: %d, geofence state: %d\n", geofence_id, state);
+}
+
+static void event_cb(int place_id, int geofence_id, geofence_manager_error_e error, geofence_manage_e manage, void *user_data)
+{
+ if (error == GEOFENCE_MANAGER_ERROR_NONE)
+ fprintf(stderr, "Place id: %d, geofence: %d, event: %d\n", place_id, geofence_id, manage);
+}
+
+static void proximity_state_changed_cb(int geofence_id, geofence_proximity_state_e state, geofence_proximity_provider_e provider, void *user_data)
+{
+ fprintf(stderr, "Geofence id: %d, proximity provider: %d, proximity state: %d\n", geofence_id, provider, state);
+}
+
+static void print_menu()
+{
+ fprintf(stderr, "============= GEOFENCE TEST =============\n");
+
+ fprintf(stderr, "[11] Show all places\n");
+ fprintf(stderr, "[12] Show all fences\n");
+ fprintf(stderr, "[13] Show all fences in specific place\n");
+
+ fprintf(stderr, "[21] Show status in specific fence\n");
+
+ fprintf(stderr, "[31] Add place\n");
+ fprintf(stderr, "[32] Update place\n");
+ fprintf(stderr, "[33] Remove place\n");
+
+ fprintf(stderr, "[41] Create and add fence: GEOFENCE_TYPE_GEOPOINT\n");
+ fprintf(stderr, "[42] Create and add fence: GEOFENCE_TYPE_WIFI\n");
+ fprintf(stderr, "[43] Create and add fence: GEOFENCE_TYPE_BT\n");
+ fprintf(stderr, "[44] Remove geofence\n");
+
+ fprintf(stderr, "[51] Start geofence\n");
+ fprintf(stderr, "[52] Stop geofence\n");
+
+ fprintf(stderr, "[0] Exit!!!\n\n");
+ fprintf(stderr, "Select menu: ");
+
+ if (scanf_safety("%d", &menu) < 0)
+ fprintf(stderr, "Can't read menu !!!\n");
+}
+
+static bool check_geofence_supported()
+{
+ fprintf(stderr, "===== GEOFENCE SUPPORT =====\n");
+
+ bool is_supported = FALSE;
+ geofence_manager_is_supported(&is_supported);
+ fprintf(stderr, "geofence support: %d\n\n", is_supported);
+
+ return is_supported;
+}
+
+static void geofence_test_init()
+{
+ int ret = 0;
+ if (manager == NULL) {
+ ret = geofence_manager_create(&manager);
+ fprintf(stderr, "geofence_manager_create: %d\n", ret);
+ show_error(ret);
+
+ ret = geofence_manager_set_geofence_state_changed_cb(manager, state_changed_cb, NULL);
+ fprintf(stderr, "set_geofence_state_changed_cb: %d\n", ret);
+
+ ret = geofence_manager_set_geofence_event_cb(manager, event_cb, NULL);
+ fprintf(stderr, "set_geofence_event_cb: %d\n", ret);
+
+ ret = geofence_manager_set_geofence_proximity_state_changed_cb(manager, proximity_state_changed_cb, NULL);
+ fprintf(stderr, "set_geofence_proximity_state_changed_cb: %d\n", ret);
+ }
+}
+
+static void geofence_test_cleanup()
+{
+ int ret = 0;
+ if (manager != NULL) {
+ ret = geofence_manager_unset_geofence_state_changed_cb(manager);
+ fprintf(stderr, "unset_geofence_state_changed_cb: %d\n", ret);
+
+ ret = geofence_manager_unset_geofence_event_cb(manager);
+ fprintf(stderr, "unset_geofence_event_cb: %d\n", ret);
+
+ ret = geofence_manager_unset_geofence_proximity_state_changed_cb(manager);
+ fprintf(stderr, "unset_geofence_proximity_state_changed_cb: %d\n", ret);
+
+ ret = geofence_manager_destroy(manager);
+ fprintf(stderr, "destroy: %d\n", ret);
+ manager = NULL;
+ }
+}
+
+static int geofence_test()
+{
+ int ret = GEOFENCE_MANAGER_ERROR_NONE;
+
+ if (!check_geofence_supported()) {
+ g_timeout_add_seconds(1, exit_program, NULL);
+ return 0;
+ }
+
+ geofence_test_init();
+ print_menu();
+
+ switch (menu) {
+ case 11: {
+ ret = geofence_manager_foreach_place_list(manager, place_list_cb, NULL);
+ fprintf(stderr, "geofence_manager_foreach_place_list: %d\n", ret);
+ break;
+ }
+ case 12: {
+ ret = geofence_manager_foreach_geofence_list(manager, fence_list_cb, NULL);
+ fprintf(stderr, "geofence_manager_foreach_geofence_list: %d\n", ret);
+ break;
+ }
+ case 13: {
+ int place_id = -1;
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ ret = geofence_manager_foreach_place_geofence_list(manager, place_id, fence_list_cb, NULL);
+ fprintf(stderr, "geofence_manager_foreach_place_list: %d\n", ret);
+ break;
+ }
+ case 21: {
+ geofence_status_h status = NULL;
+ geofence_state_e state = 0;
+ int fence_id = -1, second = -1;
+
+ fprintf(stderr, "Select fence: ");
+ ret = scanf_safety("%d", &fence_id);
+
+ ret = geofence_status_create(fence_id, &status);
+ fprintf(stderr, "geofence_status_create: %d\n", ret);
+ if (ret != 0)
+ break;
+
+ ret = geofence_status_get_state(status, &state);
+ fprintf(stderr, "geofence_status_get_state: %d\n", ret);
+
+ ret = geofence_status_get_duration(status, &second);
+ fprintf(stderr, "geofence_status_get_duration: %d\n", ret);
+
+ ret = geofence_status_destroy(status);
+ fprintf(stderr, "geofence_status_destroy: %d\n", ret);
+
+ fprintf(stderr, "Status state: %d, duration: %d\n", state, second);
+ break;
+ }
+ case 31: {
+ int place_id = -1;
+ char place_name[100] = "";
+
+ fprintf(stderr, "Insert name: ");
+ ret = scanf_safety("%s", place_name);
+
+ ret = geofence_manager_add_place(manager, place_name, &place_id);
+ fprintf(stderr, "geofence_manager_add_place: %d\n", ret);
+ break;
+ }
+ case 32: {
+ int place_id = -1;
+ char place_name[100] = "";
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ fprintf(stderr, "Insert name: ");
+ ret = scanf_safety("%s", place_name);
+
+ ret = geofence_manager_update_place(manager, place_id, place_name);
+ fprintf(stderr, "geofence_manager_update_place: %d\n", ret);
+ break;
+ }
+ case 33: {
+ int place_id = -1;
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ ret = geofence_manager_remove_place(manager, place_id);
+ fprintf(stderr, "geofence_manager_remove_place: %d\n", ret);
+ break;
+ }
+ case 41: {
+ int place_id = -1, fence_id = -1;
+ double latitude = -1.0, longitude = -1.0;
+ char address[100] = "";
+ geofence_h fence = NULL;
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ fprintf(stderr, "Insert latitude: ");
+ ret = scanf_safety("%lf", &latitude);
+
+ fprintf(stderr, "Insert longitude: ");
+ ret = scanf_safety("%lf", &longitude);
+
+ fprintf(stderr, "Insert address: ");
+ ret = scanf_safety("%s", &address);
+
+ ret = geofence_create_geopoint(place_id, latitude, longitude, 100, address, &fence);
+ fprintf(stderr, "geofence_create_geopoint: %d\n", ret);
+
+ ret = geofence_manager_add_fence(manager, fence, &fence_id);
+ fprintf(stderr, "geofence_manager_add_fence: %d\n", ret);
+ break;
+ }
+ case 42: {
+ int place_id = -1, fence_id = -1;
+ char bssid[100] = "", ssid[100] = "";
+ geofence_h fence = NULL;
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ fprintf(stderr, "Insert bssid: ");
+ ret = scanf_safety("%s", &bssid);
+
+ fprintf(stderr, "Insert ssid: ");
+ ret = scanf_safety("%s", &ssid);
+
+ ret = geofence_create_wifi(place_id, bssid, ssid, &fence);
+ fprintf(stderr, "geofence_create_wifi: %d\n", ret);
+
+ ret = geofence_manager_add_fence(manager, fence, &fence_id);
+ fprintf(stderr, "geofence_manager_add_fence: %d\n", ret);
+ break;
+ }
+ case 43: {
+ int place_id = -1, fence_id = -1;
+ char bssid[100] = "", ssid[100] = "";
+ geofence_h fence = NULL;
+
+ fprintf(stderr, "Select place: ");
+ ret = scanf_safety("%d", &place_id);
+
+ fprintf(stderr, "Insert bssid: ");
+ ret = scanf_safety("%s", &bssid);
+
+ fprintf(stderr, "Insert ssid: ");
+ ret = scanf_safety("%s", &ssid);
+
+ ret = geofence_create_bluetooth(place_id, bssid, ssid, &fence);
+ fprintf(stderr, "geofence_create_bluetooth: %d\n", ret);
+
+ ret = geofence_manager_add_fence(manager, fence, &fence_id);
+ fprintf(stderr, "geofence_manager_add_fence: %d\n", ret);
+ break;
+ }
+ case 44: {
+ int fence_id = -1;
+
+ fprintf(stderr, "Select fence: ");
+ ret = scanf_safety("%d", &fence_id);
+
+ ret = geofence_manager_remove_fence(manager, fence_id);
+ fprintf(stderr, "geofence_manager_remove_fence: %d\n", ret);
+ break;
+ }
+ case 51: {
+ int fence_id = -1;
+
+ fprintf(stderr, "Select fence: ");
+ ret = scanf_safety("%d", &fence_id);
+
+ ret = geofence_manager_start(manager, fence_id);
+ fprintf(stderr, "geofence_manager_start: %d\n", ret);
+
+ test_timer = g_timeout_add_seconds(10, wait_test, NULL);
+ return 0;
+ }
+ case 52: {
+ int fence_id = -1;
+
+ fprintf(stderr, "Select fence: ");
+ ret = scanf_safety("%d", &fence_id);
+
+ ret = geofence_manager_stop(manager, fence_id);
+ fprintf(stderr, "geofence_manager_stop: %d\n", ret);
+ break;
+ }
+ case 0:
+ default:
+ fprintf(stderr, "Exit!!! Input: %d\n", menu);
+ g_timeout_add_seconds(1, exit_program, NULL);
+ return 0;
+ }
+
+ if (ret != GEOFENCE_MANAGER_ERROR_NONE) {
+ fprintf(stderr, "Test Failed!!! [%d]\n", ret);
+ g_timeout_add_seconds(1, exit_program, NULL);
+ return 0;
+ }
+
+ test_timer = g_timeout_add_seconds(1, wait_test, NULL);
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ g_mainloop = g_main_loop_new(NULL, 0);
+ geofence_test();
+ g_main_loop_run(g_mainloop);
+ geofence_test_cleanup();
+
+ return 0;
+}
projects / platform / core / api / geofence-manager.git / commitdiff