From 924a071a70171da7d2512199f777020a55ae9056 Mon Sep 17 00:00:00 2001 From: Minjune Kim Date: Tue, 21 Aug 2012 18:10:16 +0900 Subject: [PATCH] Release Tizen2.0 beta --- TC/_export_env.sh | 8 + TC/_export_target_env.sh | 7 + TC/build.sh | 16 + TC/clean.sh | 11 + TC/config | 2 + TC/execute.sh | 15 + TC/testcase/Makefile | 25 + TC/testcase/tslist | 4 + TC/testcase/utc_location_gps_status.c | 399 +++++ TC/testcase/utc_location_location_manager.c | 1627 ++++++++++++++++++++ .../utc_location_location_manager_callback.c | 466 ++++++ TC/testcase/utc_location_preference.c | 334 ++++ TC/tet_scen | 7 + TC/tetbuild.cfg | 5 + TC/tetclean.cfg | 5 + TC/tetexec.cfg | 5 + debian/changelog | 101 +- include/location_bounds.h | 2 +- include/location_preference.h | 84 +- include/locations.h | 89 +- include/locations_private.h | 1 + packaging/capi-location-manager.spec | 7 +- src/location_bounds.c | 12 +- src/location_preference.c | 240 ++- src/locations.c | 158 +- test/location_test.c | 10 +- 26 files changed, 3460 insertions(+), 180 deletions(-) create mode 100755 TC/_export_env.sh create mode 100755 TC/_export_target_env.sh create mode 100755 TC/build.sh create mode 100755 TC/clean.sh create mode 100644 TC/config create mode 100755 TC/execute.sh create mode 100644 TC/testcase/Makefile create mode 100644 TC/testcase/tslist create mode 100755 TC/testcase/utc_location_gps_status.c create mode 100755 TC/testcase/utc_location_location_manager.c create mode 100644 TC/testcase/utc_location_location_manager_callback.c create mode 100644 TC/testcase/utc_location_preference.c create mode 100755 TC/tet_scen create mode 100644 TC/tetbuild.cfg create mode 100644 TC/tetclean.cfg create mode 100644 TC/tetexec.cfg mode change 100755 => 100644 test/location_test.c diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..72a11ec --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..5ddaa53 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,7 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config b/TC/config new file mode 100644 index 0000000..04684f0 --- /dev/null +++ b/TC/config @@ -0,0 +1,2 @@ +TET_INSTALL_HOST_PATH=/home/rookiejava/dts_tool/TETware +TET_INSTALL_TARGET_PATH=/mnt/nfs/dts_tool/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..a4f6095 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100644 index 0000000..6aadb01 --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,25 @@ +CC ?= gcc + +C_FILES = $(shell ls *.c) + +PKGS = capi-location-manager dlog glib-2.0 gthread-2.0 capi-location-geocoder + +LDFLAGS = `pkg-config --libs $(PKGS)` +LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS = -I. `pkg-config --cflags $(PKGS)` +CFLAGS += -I$(TET_ROOT)/inc/tet3 +CFLAGS += -Wall + +#TARGETS = $(C_FILES:%.c=tc-%) +TCS := $(shell ls -1 *.c | cut -d. -f1) + +all: $(TCS) + +%: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TCS) diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100644 index 0000000..f7426d5 --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1,4 @@ +/testcase/utc_location_location_manager +/testcase/utc_location_gps_status +/testcase/utc_location_location_manager_callback +/testcase/utc_location_preference diff --git a/TC/testcase/utc_location_gps_status.c b/TC/testcase/utc_location_gps_status.c new file mode 100755 index 0000000..38d698a --- /dev/null +++ b/TC/testcase/utc_location_gps_status.c @@ -0,0 +1,399 @@ +/* +* Copyright (c) 2011 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 +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_location_gps_status_get_nmea_p(void); +static void utc_location_gps_status_get_nmea_n(void); +static void utc_location_gps_status_get_nmea_n_02(void); +static void utc_location_gps_status_get_nmea_n_03(void); +static void utc_location_gps_status_get_satellite_p(void); +static void utc_location_gps_status_get_satellite_n(void); +static void utc_location_gps_status_get_satellite_n_02(void); +static void utc_location_gps_status_get_satellite_n_03(void); +static void utc_location_gps_status_get_satellite_n_04(void); +static void utc_location_gps_status_get_satellite_n_05(void); +static void utc_location_gps_status_get_satellite_n_06(void); +static void utc_location_gps_status_foreach_satellites_in_view_p(void); +static void utc_location_gps_status_foreach_satellites_in_view_n(void); +static void utc_location_gps_status_foreach_satellites_in_view_n_02(void); +static void utc_location_gps_status_foreach_satellites_in_view_n_03(void); +static void utc_location_gps_status_foreach_last_satellites_in_view_p(void); +static void utc_location_gps_status_foreach_last_satellites_in_view_n(void); +static void utc_location_gps_status_foreach_last_satellites_in_view_n_02(void); +static void utc_location_gps_status_get_last_satellite_p(void); +static void utc_location_gps_status_get_last_satellite_n(void); +static void utc_location_gps_status_get_last_satellite_n_02(void); +static void utc_location_gps_status_get_last_satellite_n_03(void); +static void utc_location_gps_status_get_last_satellite_n_04(void); + + + +struct tet_testlist tet_testlist[] = { + {utc_location_gps_status_get_nmea_p, POSITIVE_TC_IDX}, + {utc_location_gps_status_get_nmea_n, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_nmea_n_02, NEGATIVE_TC_IDX}, +// {utc_location_gps_status_get_nmea_n_03, NEGATIVE_TC_IDX}, //Can't check created location_manager_h + {utc_location_gps_status_get_satellite_p, POSITIVE_TC_IDX}, + {utc_location_gps_status_get_satellite_n, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_satellite_n_02, NEGATIVE_TC_IDX}, +// {utc_location_gps_status_get_satellite_n_03, NEGATIVE_TC_IDX}, //Can't check created location_manager_h + {utc_location_gps_status_get_satellite_n_04, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_satellite_n_05, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_satellite_n_06, NEGATIVE_TC_IDX}, + {utc_location_gps_status_foreach_satellites_in_view_p, POSITIVE_TC_IDX}, + {utc_location_gps_status_foreach_satellites_in_view_n, NEGATIVE_TC_IDX}, + {utc_location_gps_status_foreach_satellites_in_view_n_02, NEGATIVE_TC_IDX}, +// {utc_location_gps_status_foreach_satellites_in_view_n_03, NEGATIVE_TC_IDX }, //Can't check created location_manager_h + {utc_location_gps_status_foreach_last_satellites_in_view_p, POSITIVE_TC_IDX}, + {utc_location_gps_status_foreach_last_satellites_in_view_n, NEGATIVE_TC_IDX}, + {utc_location_gps_status_foreach_last_satellites_in_view_n_02, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_last_satellite_p, POSITIVE_TC_IDX}, + {utc_location_gps_status_get_last_satellite_n, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_last_satellite_n_02, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_last_satellite_n_03, NEGATIVE_TC_IDX}, + {utc_location_gps_status_get_last_satellite_n_04, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static GMainLoop *g_mainloop = NULL; +static GThread *event_thread; + +gpointer GmainThread(gpointer data) +{ + g_mainloop = g_main_loop_new(NULL, 0); + g_main_loop_run(g_mainloop); + + return NULL; +} + +static bool service_enabled = false; + +static void validate_and_next(char *api_name, int act_ret, int ext_ret, char *fail_msg) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret != ext_ret) { + dts_message(api_name, "Fail Message: %s", fail_msg); + dts_fail(api_name); + } +} + +static void validate_eq(char *api_name, int act_ret, int ext_ret) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret == ext_ret) { + dts_pass(api_name); + } else { + dts_fail(api_name); + } +} + +static void unprepare(location_manager_h manager) +{ + location_manager_unset_service_state_changed_cb(manager); + location_manager_destroy(manager); + service_enabled = false; +} + +static void wait_for_service(char *api_name) +{ + int timeout = 0; + for (timeout; timeout < 30; timeout++) { + if (service_enabled) { + dts_message(api_name, "Location Service Enabled!!!!"); + break; + } else { + dts_message(api_name, "Location Service Disabled!!!!"); + sleep(1); + } + } +} + +static void capi_state_changed_cb(location_service_state_e state, void *user_data) +{ + switch (state) { + case LOCATIONS_SERVICE_ENABLED: + service_enabled = true; + break; + case LOCATIONS_SERVICE_DISABLED: + service_enabled = false; + break; + default: + break; + } +} + +static location_manager_h manager; + +static void startup(void) +{ + g_setenv("PKG_NAME", "com.samsung.capi-location-gps-status-test", 1); + g_setenv("LOCATION_TEST_ENABLE", "1", 1); + +#if !GLIB_CHECK_VERSION (2, 31, 0) + if (!g_thread_supported()) { + g_thread_init(NULL); + } +#endif + + GError *gerr = NULL; + event_thread = g_thread_create(GmainThread, NULL, 1, &gerr); + + int ret; + ret = location_manager_create(LOCATIONS_METHOD_GPS, &manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + /* You don't need it + ret = location_manager_set_service_state_changed_cb(manager, capi_state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + */ + + ret = location_manager_start(manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); +} + +static void cleanup(void) +{ + unprepare(manager); + g_main_loop_quit(g_mainloop); + g_thread_join(event_thread); +} + +static void utc_location_gps_status_get_nmea_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + char *nmea; + ret = gps_status_get_nmea(manager, &nmea); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_gps_status_get_nmea_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_get_nmea(manager, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_nmea_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + char *nmea; + ret = gps_status_get_nmea(NULL, &nmea); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_gps_status_get_nmea_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + char *nmea; + location_manager_h manager_02; + ret = gps_status_get_nmea(manager_02, &nmea); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_gps_status_get_satellite_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_active, num_of_inview; + time_t timestamp; + ret = gps_status_get_satellite(manager, &num_of_active, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_gps_status_get_satellite_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_get_satellite(manager, NULL, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_satellite_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_active, num_of_inview; + time_t timestamp; + ret = gps_status_get_satellite(NULL, &num_of_active, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_satellite_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_active, num_of_inview; + time_t timestamp; + location_manager_h manager_02; + ret = gps_status_get_satellite(manager_02, &num_of_active, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_satellite_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_inview; + time_t timestamp; + ret = gps_status_get_satellite(manager, NULL, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_satellite_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_active; + time_t timestamp; + ret = gps_status_get_satellite(manager, &num_of_active, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_satellite_n_06(void) +{ + int ret = LOCATIONS_ERROR_NONE; + int num_of_active, num_of_inview; + ret = gps_status_get_satellite(manager, &num_of_active, &num_of_inview, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static bool capi_gps_status_get_satellites_cb(unsigned int azimuth, unsigned int elevation, unsigned int prn, int snr, + bool is_in_use, void *user_data) +{ + return true; +} + +static void utc_location_gps_status_foreach_satellites_in_view_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_foreach_satellites_in_view(manager, capi_gps_status_get_satellites_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_gps_status_foreach_satellites_in_view_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_foreach_satellites_in_view(manager, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_foreach_satellites_in_view_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_foreach_satellites_in_view(NULL, capi_gps_status_get_satellites_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_foreach_satellites_in_view_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = gps_status_foreach_satellites_in_view(manager_02, capi_gps_status_get_satellites_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static bool capi_last_satellites_foreach_cb(unsigned int azimuth, unsigned int elevation, unsigned int prn, int snr, bool is_in_use, + void *user_data) +{ + printf("[Last Satellite information] azimuth : %d, elevation : %d, prn :%d, snr : %d, used: %d\n", azimuth, elevation, + prn, snr, is_in_use); + return true; +} + +static void utc_location_gps_status_foreach_last_satellites_in_view_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = gps_status_foreach_last_satellites_in_view(manager, capi_last_satellites_foreach_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_gps_status_foreach_last_satellites_in_view_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_foreach_last_satellites_in_view(manager, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_foreach_last_satellites_in_view_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = gps_status_foreach_last_satellites_in_view(NULL, capi_last_satellites_foreach_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_last_satellite_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + time_t timestamp; + int num_of_inview, num_of_active; + ret = gps_status_get_last_satellite(manager, &num_of_active, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_gps_status_get_last_satellite_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + time_t timestamp; + int num_of_inview, num_of_active; + ret = gps_status_get_last_satellite(NULL, &num_of_active, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_last_satellite_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + time_t timestamp; + int num_of_inview; + ret = gps_status_get_last_satellite(manager, NULL, &num_of_inview, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_last_satellite_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + time_t timestamp; + int num_of_active; + ret = gps_status_get_last_satellite(manager, &num_of_active, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_gps_status_get_last_satellite_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int num_of_inview, num_of_active; + ret = gps_status_get_last_satellite(manager, &num_of_active, &num_of_inview, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + + diff --git a/TC/testcase/utc_location_location_manager.c b/TC/testcase/utc_location_location_manager.c new file mode 100755 index 0000000..ccc22e3 --- /dev/null +++ b/TC/testcase/utc_location_location_manager.c @@ -0,0 +1,1627 @@ +/* +* Copyright (c) 2011 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 +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_location_location_manager_create_p(void); +static void utc_location_location_manager_create_p_02(void); +static void utc_location_location_manager_create_p_03(void); +static void utc_location_location_manager_create_p_04(void); +static void utc_location_location_manager_create_p_05(void); +static void utc_location_location_manager_create_n(void); +static void utc_location_location_manager_create_n_02(void); +static void utc_location_location_manager_create_n_03(void); +static void utc_location_location_manager_create_n_04(void); +static void utc_location_location_manager_create_n_05(void); +static void utc_location_location_manager_create_n_06(void); +static void utc_location_location_manager_add_boundary_p(void); +static void utc_location_location_manager_add_boundary_n(void); +static void utc_location_location_manager_add_boundary_n_02(void); +static void utc_location_location_manager_add_boundary_n_03(void); +static void utc_location_location_manager_add_boundary_n_04(void); +static void utc_location_location_manager_foreach_boundary_p(void); +static void utc_location_location_manager_foreach_boundary_n(void); +static void utc_location_location_manager_foreach_boundary_n_02(void); +static void utc_location_location_manager_foreach_boundary_n_03(void); +static void utc_location_location_manager_foreach_boundary_n_04(void); +static void utc_location_location_manager_remove_boundary_p(void); +static void utc_location_location_manager_remove_boundary_n(void); +static void utc_location_location_manager_remove_boundary_n_02(void); +static void utc_location_location_manager_remove_boundary_n_03(void); +static void utc_location_location_manager_remove_boundary_n_04(void); +static void utc_location_location_manager_get_method_p(void); +static void utc_location_location_manager_get_method_n(void); +static void utc_location_location_manager_get_method_n_02(void); +static void utc_location_location_manager_get_method_n_03(void); +static void utc_location_location_manager_get_method_n_04(void); +static void utc_location_location_manager_get_position_p(void); +static void utc_location_location_manager_get_position_n(void); +static void utc_location_location_manager_get_position_n_02(void); +static void utc_location_location_manager_get_position_n_03(void); +static void utc_location_location_manager_get_position_n_04(void); +static void utc_location_location_manager_get_position_n_05(void); +static void utc_location_location_manager_get_position_n_06(void); +static void utc_location_location_manager_get_velocity_p(void); +static void utc_location_location_manager_get_velocity_n(void); +static void utc_location_location_manager_get_velocity_n_02(void); +static void utc_location_location_manager_get_velocity_n_03(void); +static void utc_location_location_manager_get_velocity_n_04(void); +static void utc_location_location_manager_get_velocity_n_05(void); +static void utc_location_location_manager_get_velocity_n_06(void); +static void utc_location_location_manager_get_accuracy_p(void); +static void utc_location_location_manager_get_accuracy_n(void); +static void utc_location_location_manager_get_accuracy_n_02(void); +static void utc_location_location_manager_get_accuracy_n_03(void); +static void utc_location_location_manager_get_accuracy_n_04(void); +static void utc_location_location_manager_get_accuracy_n_05(void); +static void utc_location_location_manager_get_accuracy_n_06(void); +static void utc_location_location_bounds_foreach_polygon_coords_p(void); +static void utc_location_location_bounds_foreach_polygon_coords_n(void); +static void utc_location_location_bounds_foreach_polygon_coords_n_02(void); +static void utc_location_location_bounds_get_circle_coords_p(void); +static void utc_location_location_bounds_get_circle_coords_n(void); +static void utc_location_location_bounds_get_circle_coords_n_02(void); +static void utc_location_location_bounds_get_circle_coords_n_03(void); +static void utc_location_location_bounds_get_rect_coords_p(void); +static void utc_location_location_bounds_get_rect_coords_n(void); +static void utc_location_location_bounds_get_rect_coords_n_02(void); +static void utc_location_location_bounds_get_rect_coords_n_03(void); +static void utc_location_location_bounds_contains_coordinates_p(void); +static void utc_location_location_bounds_contains_coordinates_p_02(void); +static void utc_location_location_bounds_contains_coordinates_n(void); +static void utc_location_location_bounds_contains_coordinates_n_02(void); +static void utc_location_location_manager_get_last_accuracy_p(void); +static void utc_location_location_manager_get_last_accuracy_n(void); +static void utc_location_location_manager_get_last_accuracy_n_02(void); +static void utc_location_location_manager_get_last_accuracy_n_03(void); +static void utc_location_location_manager_get_last_accuracy_n_04(void); +static void utc_location_location_manager_get_last_position_p(void); +static void utc_location_location_manager_get_last_position_n(void); +static void utc_location_location_manager_get_last_position_n_02(void); +static void utc_location_location_manager_get_last_position_n_03(void); +static void utc_location_location_manager_get_last_position_n_04(void); +static void utc_location_location_manager_get_last_position_n_05(void); +static void utc_location_location_manager_get_last_velocity_p(void); +static void utc_location_location_manager_get_last_velocity_n(void); +static void utc_location_location_manager_get_last_velocity_n_02(void); +static void utc_location_location_manager_get_last_velocity_n_03(void); +static void utc_location_location_manager_get_last_velocity_n_04(void); +static void utc_location_location_manager_get_last_velocity_n_05(void); +static void utc_location_location_manager_is_supported_method_p(void); +static void utc_location_location_manager_is_supported_method_p_02(void); +static void utc_location_location_manager_is_supported_method_p_03(void); +static void utc_location_location_manager_is_supported_method_p_04(void); +static void utc_location_location_manager_is_supported_method_n(void); +static void utc_location_location_manager_is_supported_method_n_02(void); +static void utc_location_location_manager_send_command_p(void); +static void utc_location_location_manager_send_command_n(void); +static void utc_location_location_manager_destroy_p(void); +static void utc_location_location_manager_destroy_n(void); +static void utc_location_location_manager_destroy_n_02(void); + +struct tet_testlist tet_testlist[] = { + {utc_location_location_manager_create_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_create_p_02, POSITIVE_TC_IDX}, + {utc_location_location_manager_create_p_03, POSITIVE_TC_IDX}, + { utc_location_location_manager_create_p_04, POSITIVE_TC_IDX }, +// { utc_location_location_manager_create_p_05, POSITIVE_TC_IDX }, // LOCATIONS_METHOD_NONE is a negative TC. + {utc_location_location_manager_create_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_create_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_create_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_manager_create_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_create_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_create_n_06, NEGATIVE_TC_IDX}, + {utc_location_location_manager_add_boundary_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_add_boundary_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_add_boundary_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_add_boundary_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_manager_add_boundary_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_foreach_boundary_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_foreach_boundary_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_foreach_boundary_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_foreach_boundary_n_03, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_foreach_boundary_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_remove_boundary_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_remove_boundary_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_remove_boundary_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_remove_boundary_n_03, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_remove_boundary_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_method_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_method_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_method_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_method_n_03, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_get_method_n_04, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_get_position_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_position_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_position_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_get_position_n_03, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_get_position_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_position_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_position_n_06, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_velocity_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_velocity_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_velocity_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_get_velocity_n_03, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_get_velocity_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_velocity_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_velocity_n_06, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_accuracy_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_accuracy_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_accuracy_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_get_accuracy_n_03, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {utc_location_location_manager_get_accuracy_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_accuracy_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_accuracy_n_06, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_foreach_polygon_coords_p, POSITIVE_TC_IDX}, + {utc_location_location_bounds_foreach_polygon_coords_n, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_foreach_polygon_coords_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_circle_coords_p, POSITIVE_TC_IDX}, + {utc_location_location_bounds_get_circle_coords_n, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_circle_coords_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_circle_coords_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_rect_coords_p, POSITIVE_TC_IDX}, + {utc_location_location_bounds_get_rect_coords_n, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_rect_coords_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_get_rect_coords_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_contains_coordinates_p, POSITIVE_TC_IDX}, + {utc_location_location_bounds_contains_coordinates_p_02, POSITIVE_TC_IDX}, + {utc_location_location_bounds_contains_coordinates_n, NEGATIVE_TC_IDX}, + {utc_location_location_bounds_contains_coordinates_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_accuracy_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_last_accuracy_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_accuracy_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_accuracy_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_accuracy_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_position_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_n_03, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_n_04, NEGATIVE_TC_IDX}, + {utc_location_location_manager_get_last_velocity_n_05, NEGATIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_p_02, POSITIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_p_03, POSITIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_p_04, POSITIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_is_supported_method_n_02, NEGATIVE_TC_IDX}, + {utc_location_location_manager_destroy_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_destroy_n, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_destroy_n_02, NEGATIVE_TC_IDX }, // Can't check created location_manager_h + {NULL, 0}, +}; + +static bool service_enabled = false; +static bool touch_foreach_bounds = false; + +static GMainLoop *g_mainloop = NULL; +static GThread *event_thread; + +gpointer GmainThread(gpointer data) +{ + g_mainloop = g_main_loop_new(NULL, 0); + g_main_loop_run(g_mainloop); + return NULL; +} + +static void validate_and_next(char *api_name, int act_ret, int ext_ret, char *fail_msg) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret != ext_ret) { + dts_message(api_name, "Fail Message: %s", fail_msg); + dts_fail(api_name); + } +} + +static void validate_eq(char *api_name, int act_ret, int ext_ret) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret == ext_ret) { + dts_pass(api_name); + } else { + dts_fail(api_name); + } +} + +static void wait_for_service(char *api_name) +{ + int timeout = 0; + for (timeout; timeout < 60; timeout++) { + if (service_enabled) { + dts_message(api_name, "Location Service Enabled!!!!"); + break; + } else { + dts_message(api_name, "Location Service Disabled!!!!"); + sleep(1); + } + } +} + +static void wait_for_bounds_foreach(char *api_name) +{ + int timeout = 0; + for (timeout; timeout < 30; timeout++) { + if (touch_foreach_bounds) { + dts_message(api_name, "bound foreach called!!!!"); + break; + } else { + dts_message(api_name, "No bound foreach!!!!"); + sleep(1); + } + } +} + +static void __state_changed_cb(location_service_state_e state, void *user_data) +{ + switch (state) { + case LOCATIONS_SERVICE_ENABLED: + service_enabled = true; + break; + case LOCATIONS_SERVICE_DISABLED: + service_enabled = false; + break; + default: + break; + } +} + +static bool __location_bounds_cb(location_bounds_h bounds, void *user_data) +{ + if (bounds == NULL) + printf("bounds ==NULL\n"); + else { + location_bounds_type_e type; + location_bounds_get_type(bounds, &type); + dts_message(__func__, "__location_bounds_cb - type : %d!!!!", type); + touch_foreach_bounds = TRUE; + } + return TRUE; +} + +static location_manager_h manager; +static location_bounds_h bounds_rect; +static location_bounds_h bounds_circle; +static location_bounds_h bounds_poly; + +static void startup(void) +{ + g_setenv("PKG_NAME", "com.samsung.capi-location-manager-test", 1); + g_setenv("LOCATION_TEST_ENABLE", "1", 1); + +#if !GLIB_CHECK_VERSION (2, 31, 0) + if (!g_thread_supported()) { + g_thread_init(NULL); + } +#endif + + event_thread = g_thread_create(GmainThread, NULL, 1, NULL); +} + +static void cleanup(void) +{ + if (manager) { + location_manager_unset_service_state_changed_cb(manager); + location_manager_stop(manager); + location_manager_destroy(manager); + manager = NULL; + } + + service_enabled = false; + touch_foreach_bounds = false; + g_main_loop_quit(g_mainloop); + g_thread_join(event_thread); +} + +static void utc_location_location_manager_create_p(void) +{ + int ret; + + ret = location_manager_create(LOCATIONS_METHOD_HYBRID, &manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager, __state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); + + /* + location_manager_stop(manager); //If you call start() and then stop(), service_enabled always set false. + location_manager_unset_service_state_changed_cb(manager); + */ + + validate_eq(__func__, service_enabled, true); +} + +static void utc_location_location_manager_create_p_02(void) +{ + int ret; + location_manager_h manager_02; + + ret = location_manager_create(LOCATIONS_METHOD_GPS, &manager_02); + + /* We don't need it + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager_02, __state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); + + location_manager_stop(manager_02); + location_manager_unset_service_state_changed_cb(manager_02); + */ + + location_manager_destroy(manager_02); + + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_create_p_03(void) +{ + int ret; + location_manager_h manager_02; + + ret = location_manager_create(LOCATIONS_METHOD_WPS, &manager_02); + + /* We don't need it + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager_02, __state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); + + location_manager_stop(manager_02); + location_manager_unset_service_state_changed_cb(manager_02); + */ + + location_manager_destroy(manager_02); + + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_create_p_04(void) +{ + int ret; + location_manager_h manager_02; + + ret = location_manager_create(LOCATIONS_METHOD_CPS, &manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager_02, __state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); + + location_manager_stop(manager_02); + location_manager_unset_service_state_changed_cb(manager_02); + location_manager_destroy(manager_02); + + validate_eq(__func__, service_enabled, TRUE); +} + +static void utc_location_location_manager_create_p_05(void) +{ + int ret; + location_manager_h manager_02; + + ret = location_manager_create(LOCATIONS_METHOD_NONE, &manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager_02, __state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager_02); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + + wait_for_service(__func__); + + location_manager_stop(manager_02); + location_manager_unset_service_state_changed_cb(manager_02); + location_manager_destroy(manager_02); + + validate_eq(__func__, service_enabled, TRUE); +} + +static void utc_location_location_manager_create_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_HYBRID, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_create_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_NONE, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_create_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_GPS, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_create_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_WPS, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_create_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_CPS, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_create_n_06(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + + ret = location_manager_create(LOCATIONS_METHOD_CPS + 1, &manager_02); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_add_boundary_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the circle bounds + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + ret = location_manager_add_boundary(manager, bounds_circle); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_add_boundary() is failed"); + + //Add the rect bounds + location_coords_s left_top; + left_top.latitude = 30; + left_top.longitude = 30; + + location_coords_s right_bottom; + right_bottom.latitude = 10; + right_bottom.longitude = 50; + + ret = location_bounds_create_rect(left_top, right_bottom, &bounds_rect); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_rect() is failed"); + + ret = location_manager_add_boundary(manager, bounds_rect); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_add_boundary() is failed"); + + //Add the polygon bounds + + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 30; + + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + ret = location_manager_add_boundary(manager, bounds_poly); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_add_boundary_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_add_boundary(NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_add_boundary_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_add_boundary(manager, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_add_boundary_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the circle bounds + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + ret = location_manager_add_boundary(NULL, bounds_circle); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_add_boundary_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + + //Add the circle bounds + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + ret = location_manager_add_boundary(manager_02, bounds_circle); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_foreach_boundary_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_foreach_boundary(manager, __location_bounds_cb, (void *)manager); + validate_and_next(__func__, ret, LOCATION_BOUNDS_ERROR_NONE, "location_manager_foreach_boundary() is failed"); + wait_for_bounds_foreach(__func__); + validate_eq(__func__, touch_foreach_bounds, TRUE); +} + +static void utc_location_location_manager_foreach_boundary_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_foreach_boundary(NULL, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_foreach_boundary_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_foreach_boundary(NULL, __location_bounds_cb, (void *)manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_foreach_boundary_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_foreach_boundary(manager_02, __location_bounds_cb, (void *)manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_foreach_boundary_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_foreach_boundary(manager, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_remove_boundary_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_remove_boundary(manager, bounds_rect); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_remove_boundary(rect) is failed"); + ret = location_manager_remove_boundary(manager, bounds_circle); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_remove_boundary(circle) is failed"); + ret = location_manager_remove_boundary(manager, bounds_poly); + location_bounds_destroy(bounds_rect); + location_bounds_destroy(bounds_circle); + location_bounds_destroy(bounds_poly); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_remove_boundary_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_remove_boundary(NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_remove_boundary_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_remove_boundary(NULL, bounds_rect); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_remove_boundary_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_remove_boundary(manager_02, bounds_rect); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_remove_boundary_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_remove_boundary(manager, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_method_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_method_e method; + ret = location_manager_get_method(manager, &method); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_method_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_get_method(NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_get_method_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_get_method(manager, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_get_method_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_method_e method; + ret = location_manager_get_method(NULL, &method); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_get_method_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + location_method_e method; + ret = location_manager_get_method(manager_02, &method); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_get_position_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_position(manager, &altitude, &latitude, &longitude, ×tamp); + dts_message(__func__, "altitude : %lf, latitude : %lf, longitude : %lf, timestamp:%d", latitude, latitude, longitude, + timestamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_position_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_position(manager, NULL, &latitude, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_position_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_position(NULL, &altitude, &latitude, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_position_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + time_t timestamp; + location_manager_h manager_02; + + ret = location_manager_get_position(manager_02, &altitude, &latitude, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_position_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_position(manager, &altitude, NULL, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_position_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + time_t timestamp; + + ret = location_manager_get_position(manager, &altitude, &latitude, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_position_n_06(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + + ret = location_manager_get_position(manager, &altitude, &latitude, &longitude, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_velocity(manager, &climb, &direction, &speed, ×tamp); + dts_message(__func__, "climb : %lf, direction : %lf, speed : %lf, timestamp:%d", climb, direction, speed, timestamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_velocity_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_velocity(manager, NULL, &direction, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_velocity(NULL, &climb, &direction, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + time_t timestamp; + location_manager_h manager_02; + + ret = location_manager_get_velocity(manager_02, &climb, &direction, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int speed; + time_t timestamp; + + ret = location_manager_get_velocity(manager, &climb, NULL, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + time_t timestamp; + + ret = location_manager_get_velocity(manager, &climb, &direction, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_velocity_n_06(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + + ret = location_manager_get_velocity(manager, &climb, &direction, &speed, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_accuracy_level_e level; + double horizontal; + double vertical; + + ret = location_manager_get_accuracy(manager, &level, &horizontal, &vertical); + dts_message(__func__, "Level : %lf, horizontal : %lf, vertical : %lf", level, horizontal, vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_accuracy_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_get_accuracy(manager, NULL, NULL, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_accuracy_level_e level; + double horizontal; + double vertical; + + ret = location_manager_get_accuracy(NULL, &level, &horizontal, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_accuracy_level_e level; + double horizontal; + double vertical; + location_manager_h manager_02; + + ret = location_manager_get_accuracy(manager_02, &level, &horizontal, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double horizontal; + double vertical; + + ret = location_manager_get_accuracy(manager, NULL, &horizontal, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_accuracy_level_e level; + double vertical; + + ret = location_manager_get_accuracy(manager, &level, NULL, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_accuracy_n_06(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_accuracy_level_e level; + double horizontal; + + ret = location_manager_get_accuracy(manager, &level, &horizontal, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static bool capi_poly_coords_cb(location_coords_s coords, void *user_data) +{ + printf("location_bounds_foreach_rect_coords(latitude : %lf, longitude: %lf) \n", coords.latitude, coords.longitude); + return TRUE; +} + +static void utc_location_location_bounds_foreach_polygon_coords_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the polygon bounds + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 30; + + location_bounds_h bounds_poly; + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + ret = location_bounds_foreach_polygon_coords(bounds_poly, capi_poly_coords_cb, NULL); + + location_bounds_destroy(bounds_poly); + + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_bounds_foreach_polygon_coords_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_bounds_foreach_polygon_coords(NULL, capi_poly_coords_cb, NULL); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_foreach_polygon_coords_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the polygon bounds + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 30; + + location_bounds_h bounds_poly; + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + ret = location_bounds_foreach_polygon_coords(bounds_poly, NULL, NULL); + + location_bounds_destroy(bounds_poly); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_circle_coords_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + location_bounds_h bounds_circle; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + location_coords_s center2; + double radius2; + ret = location_bounds_get_circle_coords(bounds_circle, ¢er2, &radius2); + + location_bounds_destroy(bounds_circle); + + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_bounds_get_circle_coords_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s center2; + double radius2; + ret = location_bounds_get_circle_coords(NULL, ¢er2, &radius2); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_circle_coords_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + location_bounds_h bounds_circle; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + double radius2; + ret = location_bounds_get_circle_coords(bounds_circle, NULL, &radius2); + + location_bounds_destroy(bounds_circle); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_circle_coords_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s center; + center.latitude = 37.258; + center.longitude = 127.056; + double radius = 30; + location_bounds_h bounds_circle; + ret = location_bounds_create_circle(center, radius, &bounds_circle); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_circle() is failed"); + + location_coords_s center2; + ret = location_bounds_get_circle_coords(bounds_circle, ¢er2, NULL); + + location_bounds_destroy(bounds_circle); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_rect_coords_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the rect bounds + location_coords_s left_top; + left_top.latitude = 30; + left_top.longitude = 30; + + location_coords_s right_bottom; + right_bottom.latitude = 10; + right_bottom.longitude = 50; + + location_bounds_h bounds_rect; + ret = location_bounds_create_rect(left_top, right_bottom, &bounds_rect); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_rect() is failed"); + + location_coords_s left_top2; + location_coords_s right_bottom2; + ret = location_bounds_get_rect_coords(bounds_rect, &left_top2, &right_bottom2); + + location_bounds_destroy(bounds_rect); + + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_bounds_get_rect_coords_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s left_top2; + location_coords_s right_bottom2; + ret = location_bounds_get_rect_coords(NULL, &left_top2, &right_bottom2); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_rect_coords_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the rect bounds + location_coords_s left_top; + left_top.latitude = 30; + left_top.longitude = 30; + + location_coords_s right_bottom; + right_bottom.latitude = 10; + right_bottom.longitude = 50; + + location_bounds_h bounds_rect; + ret = location_bounds_create_rect(left_top, right_bottom, &bounds_rect); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_rect() is failed"); + + location_coords_s right_bottom2; + ret = location_bounds_get_rect_coords(bounds_rect, NULL, &right_bottom2); + + location_bounds_destroy(bounds_rect); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_get_rect_coords_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the rect bounds + location_coords_s left_top; + left_top.latitude = 30; + left_top.longitude = 30; + + location_coords_s right_bottom; + right_bottom.latitude = 10; + right_bottom.longitude = 50; + + location_bounds_h bounds_rect; + ret = location_bounds_create_rect(left_top, right_bottom, &bounds_rect); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_rect() is failed"); + + location_coords_s left_top2; + ret = location_bounds_get_rect_coords(bounds_rect, &left_top2, NULL); + + location_bounds_destroy(bounds_rect); + + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_bounds_contains_coordinates_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the polygon bounds + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 10; + + location_bounds_h bounds_poly; + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + location_coords_s test_coords; + test_coords.latitude = 20; + test_coords.longitude = 12; + bool contained = FALSE; + contained = location_bounds_contains_coordinates(bounds_poly, test_coords); + + location_bounds_destroy(bounds_poly); + + validate_eq(__func__, contained, TRUE); +} + +static void utc_location_location_bounds_contains_coordinates_p_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the polygon bounds + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 10; + + location_bounds_h bounds_poly; + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + location_coords_s test_coords; + test_coords.latitude = 50; + test_coords.longitude = 50; + bool contained = FALSE; + contained = location_bounds_contains_coordinates(bounds_poly, test_coords); + + location_bounds_destroy(bounds_poly); + + validate_eq(__func__, contained, FALSE); +} + + +static void utc_location_location_bounds_contains_coordinates_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_coords_s test_coords; + test_coords.latitude = 12; + test_coords.longitude = 12; + ret = location_bounds_contains_coordinates(NULL, test_coords); + + validate_eq(__func__, ret, FALSE); +} + +static void utc_location_location_bounds_contains_coordinates_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + //Add the polygon bounds + int poly_size = 3; + location_coords_s coord_list[poly_size]; + + coord_list[0].latitude = 10; + coord_list[0].longitude = 10; + coord_list[1].latitude = 20; + coord_list[1].longitude = 20; + coord_list[2].latitude = 30; + coord_list[2].longitude = 10; + + location_bounds_h bounds_poly; + ret = location_bounds_create_polygon(coord_list, poly_size, &bounds_poly); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_bounds_create_polygon() is failed"); + + location_coords_s coord_test; + coord_test.latitude = -91; + coord_test.longitude = 181; + ret = location_bounds_contains_coordinates(bounds_poly, coord_test); + + location_bounds_destroy(bounds_poly); + + validate_eq(__func__, ret, FALSE); +} + +static void utc_location_location_manager_get_last_accuracy_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + + double horizontal, vertical; + location_accuracy_level_e level; + + ret = location_manager_get_last_accuracy(manager, &level, &horizontal, &vertical); + dts_message(__func__, "Level : %d, horizontal: %g, vertical : %g\n", level, horizontal, vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_last_accuracy_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double horizontal, vertical; + location_accuracy_level_e level; + + ret = location_manager_get_last_accuracy(NULL, &level, &horizontal, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_accuracy_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double horizontal, vertical; + + ret = location_manager_get_last_accuracy(manager, NULL, &horizontal, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_accuracy_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double vertical; + location_accuracy_level_e level; + + ret = location_manager_get_last_accuracy(manager, &level, NULL, &vertical); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_accuracy_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double horizontal; + location_accuracy_level_e level; + + ret = location_manager_get_last_accuracy(manager, &level, &horizontal, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_position_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_last_position(manager, &altitude, &latitude, &longitude, ×tamp); + dts_message(__func__, "altitude : %lf, latitude : %lf, longitude : %lf, timestamp:%d", latitude, latitude, longitude, + timestamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_last_position_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_last_position(NULL, &altitude, &latitude, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_position_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double latitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_last_position(manager, NULL, &latitude, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_position_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double longitude; + time_t timestamp; + + ret = location_manager_get_last_position(manager, &altitude, NULL, &longitude, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_position_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + time_t timestamp; + + ret = location_manager_get_last_position(manager, &altitude, &latitude, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_position_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + double altitude; + double latitude; + double longitude; + + ret = location_manager_get_last_position(manager, &altitude, &latitude, &longitude, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_velocity_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_last_velocity(manager, &climb, &direction, &speed, ×tamp); + dts_message(__func__, "climb : %lf, direction : %lf, speed : %lf, timestamp:%d", climb, direction, speed, timestamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_get_last_velocity_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_last_velocity(NULL, &climb, &direction, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_velocity_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int direction; + int speed; + time_t timestamp; + + ret = location_manager_get_last_velocity(manager, NULL, &direction, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_velocity_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int speed; + time_t timestamp; + + ret = location_manager_get_last_velocity(manager, &climb, NULL, &speed, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_velocity_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + time_t timestamp; + + ret = location_manager_get_last_velocity(manager, &climb, &direction, NULL, ×tamp); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_get_last_velocity_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + int climb; + int direction; + int speed; + + ret = location_manager_get_last_velocity(manager, &climb, &direction, &speed, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_is_supported_method_p(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_HYBRID); + validate_eq(__func__, supported, TRUE); +} + +static void utc_location_location_manager_is_supported_method_p_02(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_GPS); + validate_eq(__func__, supported, TRUE); +} + +static void utc_location_location_manager_is_supported_method_p_03(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_WPS); + validate_eq(__func__, supported, TRUE); +} + +static void utc_location_location_manager_is_supported_method_p_04(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_CPS); + validate_eq(__func__, supported, TRUE); +} + +static void utc_location_location_manager_is_supported_method_n(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_NONE); + validate_eq(__func__, supported, FALSE); +} + +static void utc_location_location_manager_is_supported_method_n_02(void) +{ + bool supported = FALSE; + supported = location_manager_is_supported_method(LOCATIONS_METHOD_CPS + 1); + validate_eq(__func__, supported, FALSE); +} + +static void utc_location_location_manager_send_command_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + + const *str = "command"; + ret = location_manager_send_command(str); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_send_command_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_send_command(NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_destroy_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_destroy(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_destroy_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_destroy(NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} + +static void utc_location_location_manager_destroy_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_manager_h manager_02; + + ret = location_manager_destroy(manager_02); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); + +} diff --git a/TC/testcase/utc_location_location_manager_callback.c b/TC/testcase/utc_location_location_manager_callback.c new file mode 100644 index 0000000..7d4c70d --- /dev/null +++ b/TC/testcase/utc_location_location_manager_callback.c @@ -0,0 +1,466 @@ +/* +* Copyright (c) 2011 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 +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_location_location_manager_start_p(void); +static void utc_location_location_manager_start_n(void); +static void utc_location_location_manager_start_n_02(void); +static void utc_location_location_manager_set_position_updated_callback_p(void); +static void utc_location_location_manager_set_position_updated_callback_n(void); +static void utc_location_location_manager_set_position_updated_callback_n_02(void); +static void utc_location_location_manager_set_position_updated_callback_n_03(void); +static void utc_location_location_manager_set_position_updated_callback_n_04(void); +static void utc_location_location_manager_set_position_updated_callback_n_05(void); +static void utc_location_location_manager_unset_position_updated_callback_p(void); +static void utc_location_location_manager_unset_position_updated_callback_n(void); +static void utc_location_location_manager_set_velocity_updated_callback_p(void); +static void utc_location_location_manager_set_velocity_updated_callback_n(void); +static void utc_location_location_manager_set_velocity_updated_callback_n_02(void); +static void utc_location_location_manager_set_velocity_updated_callback_n_03(void); +static void utc_location_location_manager_unset_velocity_updated_callback_p(void); +static void utc_location_location_manager_unset_velocity_updated_callback_n(void); +static void utc_location_location_manager_set_service_state_changed_callback_p(void); +static void utc_location_location_manager_set_service_state_changed_callback_n(void); +static void utc_location_location_manager_set_service_state_changed_callback_n_02(void); +static void utc_location_location_manager_set_service_state_changed_callback_n_03(void); +static void utc_location_location_manager_unset_service_state_changed_callback_p(void); +static void utc_location_location_manager_unset_service_state_changed_callback_n(void); +static void utc_location_location_manager_set_zone_changed_callback_p(void); +static void utc_location_location_manager_set_zone_changed_callback_n(void); +static void utc_location_location_manager_set_zone_changed_callback_n_02(void); +static void utc_location_location_manager_set_zone_changed_callback_n_03(void); +static void utc_location_location_manager_unset_zone_changed_callback_p(void); +static void utc_location_location_manager_unset_zone_changed_callback_n(void); +static void utc_location_location_manager_stop_p(void); +static void utc_location_location_manager_stop_n(void); +static void utc_location_location_manager_stop_n_02(void); + +struct tet_testlist tet_testlist[] = { + {utc_location_location_manager_start_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_start_n, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_start_n_02, NEGATIVE_TC_IDX }, //Can't check address of created location_manager_h + {utc_location_location_manager_set_position_updated_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_set_position_updated_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_unset_position_updated_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_unset_position_updated_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_velocity_updated_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_set_velocity_updated_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_velocity_updated_callback_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_set_velocity_updated_callback_n_03, NEGATIVE_TC_IDX }, //Can't check address of created location_manager_h + {utc_location_location_manager_unset_velocity_updated_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_unset_velocity_updated_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_service_state_changed_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_set_service_state_changed_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_service_state_changed_callback_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_set_service_state_changed_callback_n_03, NEGATIVE_TC_IDX }, // Can't check address of created location_manager_h + {utc_location_location_manager_unset_service_state_changed_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_unset_service_state_changed_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_zone_changed_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_set_zone_changed_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_set_zone_changed_callback_n_02, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_set_zone_changed_callback_n_03, NEGATIVE_TC_IDX }, // Can't check address of created location_manager_h + {utc_location_location_manager_unset_zone_changed_callback_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_unset_zone_changed_callback_n, NEGATIVE_TC_IDX}, + {utc_location_location_manager_stop_p, POSITIVE_TC_IDX}, + {utc_location_location_manager_stop_n, NEGATIVE_TC_IDX}, +// { utc_location_location_manager_stop_n_02, NEGATIVE_TC_IDX }, //Can't check address of created location_manager_h + {NULL, 0}, +}; + +static bool service_enabled = false; + +static void validate_and_next(char *api_name, int act_ret, int ext_ret, char *fail_msg) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret != ext_ret) { + dts_message(api_name, "Fail Message: %s", fail_msg); + dts_fail(api_name); + } +} + +static void validate_eq(char *api_name, int act_ret, int ext_ret) +{ + dts_message(api_name, "Actual Result : %d, Expected Result : %d", act_ret, ext_ret); + if (act_ret == ext_ret) { + dts_pass(api_name); + } else { + dts_fail(api_name); + } +} + +static void validate_neq(char *api_name, int act_ret, int ext_ret) +{ + dts_message(api_name, "Actual Result : %d, N-Expected Result : %d", act_ret, ext_ret); + if (act_ret != ext_ret) { + dts_pass(api_name); + } else { + dts_fail(api_name); + } +} + +static void unprepare(location_manager_h manager) +{ + location_manager_unset_service_state_changed_cb(manager); + location_manager_destroy(manager); + service_enabled = false; +} + +static void wait_for_service(char *api_name) +{ + int timeout = 0; + for (timeout; timeout < 30; timeout++) { + if (service_enabled) { + dts_message(api_name, "Location Service Enabled!!!!"); + break; + } else { + dts_message(api_name, "Location Service Disabled!!!!"); + sleep(1); + } + } +} + +static void capi_state_changed_cb(location_service_state_e state, void *user_data) +{ + switch (state) { + case LOCATIONS_SERVICE_ENABLED: + service_enabled = true; + break; + case LOCATIONS_SERVICE_DISABLED: + service_enabled = false; + break; + default: + break; + } +} + +static GMainLoop *g_mainloop = NULL; +static GThread *event_thread; + +gpointer GmainThread(gpointer data) +{ + g_mainloop = g_main_loop_new(NULL, 0); + g_main_loop_run(g_mainloop); + return NULL; +} + +static location_manager_h manager; + +static void startup(void) +{ + g_setenv("PKG_NAME", "com.samsung.capi-location-manager-callback-test", 1); + g_setenv("LOCATION_TEST_ENABLE", "1", 1); + +#if !GLIB_CHECK_VERSION (2, 31, 0) + if (!g_thread_supported()) { + g_thread_init(NULL); + } +#endif + + GError *gerr = NULL; + event_thread = g_thread_create(GmainThread, NULL, 1, &gerr); + +} + +static void cleanup(void) +{ + unprepare(manager); + g_main_loop_quit(g_mainloop); + g_thread_join(event_thread); +} + +static void capi_position_updated_cb(double latitude, double longitude, double altitude, time_t timestamp, void *user_data) +{ +} + +static void capi_zone_changed_cb(location_boundary_state_e state, double latitude, double longitude, double altitude, + time_t timestamp, void *user_data) +{ +} + +static void capi_velocity_updated_cb(double speed, double direction, double climb, time_t timestamp, void *user_data) +{ +} + +static bool capi_geocoder_get_position_cb(double latitude, double longitude, void *user_data) +{ + return true; +} + +static void utc_location_location_manager_start_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_create(LOCATIONS_METHOD_HYBRID, &manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_create() is failed"); + + ret = location_manager_set_service_state_changed_cb(manager, capi_state_changed_cb, NULL); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_set_service_state_changed_cb() is failed"); + + ret = location_manager_start(manager); + validate_and_next(__func__, ret, LOCATIONS_ERROR_NONE, "location_manager_start() is failed"); + wait_for_service(__func__); + + validate_eq(__func__, service_enabled, true); + +} + +static void utc_location_location_manager_start_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_start(NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_start_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + location_manager_h manager_02; + + ret = location_manager_start(manager_02); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_set_position_updated_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_position_updated_cb(manager, capi_position_updated_cb, 1, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_position_updated_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_position_updated_cb(manager, NULL, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_position_updated_callback_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_position_updated_cb(NULL, capi_position_updated_cb, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_position_updated_callback_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_set_position_updated_cb(manager_02, capi_position_updated_cb, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_position_updated_callback_n_04(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_position_updated_cb(manager, capi_position_updated_cb, 0, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_position_updated_callback_n_05(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_position_updated_cb(manager, capi_position_updated_cb, 121, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_position_updated_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_position_updated_cb(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_position_updated_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_position_updated_cb(NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_velocity_updated_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_velocity_updated_cb(manager, capi_velocity_updated_cb, 1, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_velocity_updated_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_velocity_updated_cb(manager, NULL, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_set_velocity_updated_callback_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_velocity_updated_cb(NULL, capi_velocity_updated_cb, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_set_velocity_updated_callback_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_set_velocity_updated_cb(manager_02, capi_velocity_updated_cb, 1, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_unset_velocity_updated_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_velocity_updated_cb(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_velocity_updated_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_velocity_updated_cb(NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_service_state_changed_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_service_state_changed_cb(manager, capi_state_changed_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_service_state_changed_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_service_state_changed_cb(manager, NULL, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_service_state_changed_callback_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_service_state_changed_cb(NULL, capi_state_changed_cb, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_service_state_changed_callback_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_set_service_state_changed_cb(manager_02, capi_state_changed_cb, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_service_state_changed_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_service_state_changed_cb(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_service_state_changed_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_service_state_changed_cb(NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_set_zone_changed_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_zone_changed_cb(manager, capi_zone_changed_cb, NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); + +} + +static void utc_location_location_manager_set_zone_changed_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_zone_changed_cb(manager, NULL, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_zone_changed_callback_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_set_zone_changed_cb(NULL, capi_zone_changed_cb, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_set_zone_changed_callback_n_03(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + ret = location_manager_set_zone_changed_cb(manager_02, capi_zone_changed_cb, NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_zone_changed_callback_p(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_zone_changed_cb(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_unset_zone_changed_callback_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_unset_zone_changed_cb(NULL); + validate_neq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_stop_p(void) +{ + + int ret = LOCATIONS_ERROR_NONE; + ret = location_manager_stop(manager); + validate_eq(__func__, ret, LOCATIONS_ERROR_NONE); +} + +static void utc_location_location_manager_stop_n(void) +{ + int ret = LOCATIONS_ERROR_NONE; + + ret = location_manager_stop(NULL); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} + +static void utc_location_location_manager_stop_n_02(void) +{ + int ret = LOCATIONS_ERROR_NONE; + location_manager_h manager_02; + + ret = location_manager_stop(manager_02); + validate_eq(__func__, ret, LOCATIONS_ERROR_INVALID_PARAMETER); +} diff --git a/TC/testcase/utc_location_preference.c b/TC/testcase/utc_location_preference.c new file mode 100644 index 0000000..63f5bb7 --- /dev/null +++ b/TC/testcase/utc_location_preference.c @@ -0,0 +1,334 @@ +/* +* Copyright (c) 2011 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 +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_location_location_preference_foreach_available_property_keys_p(void); +static void utc_location_location_preference_foreach_available_property_keys_n(void); +static void utc_location_location_preference_foreach_available_property_values_p(void); +static void utc_location_location_preference_foreach_available_property_values_n(void); +static void utc_location_location_preference_foreach_available_languages_p(void); +static void utc_location_location_preference_foreach_available_languages_n(void); +static void utc_location_location_preference_foreach_properties_p(void); +static void utc_location_location_preference_foreach_properties_n(void); +static void utc_location_location_preference_set_p(void); +static void utc_location_location_preference_set_n(void); +static void utc_location_location_preference_get_p(void); +static void utc_location_location_preference_get_n(void); +static void utc_location_location_preference_get_provider_name_p(void); +static void utc_location_location_preference_get_provider_name_n(void); +static void utc_location_location_preference_get_distance_unit_p(void); +static void utc_location_location_preference_get_distance_unit_n(void); +static void utc_location_location_preference_set_distance_unit_p(void); +static void utc_location_location_preference_set_distance_unit_n(void); +static void utc_location_location_preference_get_language_p(void); +static void utc_location_location_preference_get_language_n(void); +static void utc_location_location_preference_set_language_p(void); +static void utc_location_location_preference_set_language_n(void); + +struct tet_testlist tet_testlist[] = { +// { utc_location_location_preference_foreach_available_property_keys_p, POSITIVE_TC_IDX }, + {utc_location_location_preference_foreach_available_property_keys_n, NEGATIVE_TC_IDX}, +// { utc_location_location_preference_foreach_available_property_values_p, POSITIVE_TC_IDX }, + {utc_location_location_preference_foreach_available_property_values_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_foreach_available_languages_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_foreach_available_languages_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_set_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_set_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_foreach_properties_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_foreach_properties_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_get_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_get_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_get_provider_name_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_get_provider_name_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_set_distance_unit_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_set_distance_unit_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_get_distance_unit_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_get_distance_unit_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_set_language_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_set_language_n, NEGATIVE_TC_IDX}, + {utc_location_location_preference_get_language_p, POSITIVE_TC_IDX}, + {utc_location_location_preference_get_language_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static geocoder_h geocoder; +static char *available_language; +static char *available_key; +static char *available_value; + +static void startup(void) +{ + g_setenv("PKG_NAME", "com.samsung.capi-location-preference", 1); + g_setenv("LOCATION_TEST_ENABLE", "1", 1); + + tet_printf("TC start"); + + int ret = geocoder_create(&geocoder); + available_language = NULL; + available_key = NULL; + available_value = NULL; + if (ret != GEOCODER_ERROR_NONE) { + tet_printf("Creating the handle of geocoder failed"); + return; + } else { + tet_printf("Creating the handle of geocoder succeeded"); + } +} + +static void cleanup(void) +{ + geocoder_destroy(geocoder); +} + +bool location_preference_available_property_key_cb_impl(const char *key, void *user_data) +{ + tet_printf("key : %s", key); + available_key = strdup(key); + return false; +} + +bool location_preference_available_property_value_cb_impl(const char *value, void *user_data) +{ + tet_printf("value : %s", value); + available_value = strdup(value); + return false; +} + +bool location_preference_available_language_cb_impl(const char *language, void *user_data) +{ + available_language = strdup(language); + tet_printf("available language : %s", available_language); + return false; +} + +bool location_preference_property_cb_impl(const char *key, const char *value, void *user_data) +{ + tet_printf("key : %s", key); + tet_printf("value : %s", value); + return false; +} + +static void utc_location_location_preference_foreach_available_property_keys_p(void) +{ + int ret = location_preference_foreach_available_property_keys(GET_LOCATION_SERVICE(geocoder), + location_preference_available_property_key_cb_impl, NULL); + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + dts_pass(__func__, "location_preference_foreach_available_property_keys passed"); + } else { + dts_fail(__func__, "location_preference_foreach_available_property_keys failed"); + } +} + +static void utc_location_location_preference_foreach_available_property_keys_n(void) +{ + int ret = location_preference_foreach_available_property_keys(GET_LOCATION_SERVICE(geocoder), NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_foreach_available_property_values_p(void) +{ + int ret = location_preference_foreach_available_property_values(GET_LOCATION_SERVICE(geocoder), available_key, + location_preference_available_property_value_cb_impl, + NULL); + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + dts_pass(__func__, "location_preference_foreach_available_property_values passed"); + } else { + dts_fail(__func__, "location_preference_foreach_available_property_values failed"); + } +} + +static void utc_location_location_preference_foreach_available_property_values_n(void) +{ + int ret = location_preference_foreach_available_property_values(GET_LOCATION_SERVICE(geocoder), NULL, NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_foreach_available_languages_p(void) +{ + int ret = location_preference_foreach_available_languages(GET_LOCATION_SERVICE(geocoder), + location_preference_available_language_cb_impl, NULL); + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + dts_pass(__func__, "location_preference_foreach_available_languages passed"); + } else { + dts_fail(__func__, "location_preference_foreach_available_languages failed"); + } +} + +static void utc_location_location_preference_foreach_available_languages_n(void) +{ + int ret = location_preference_foreach_available_languages(GET_LOCATION_SERVICE(geocoder), NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_foreach_properties_p(void) +{ + int ret = + location_preference_foreach_properties(GET_LOCATION_SERVICE(geocoder), location_preference_property_cb_impl, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_NONE, "location_preference_foreach_properties failed."); +} + +static void utc_location_location_preference_foreach_properties_n(void) +{ + int ret = location_preference_foreach_properties(GET_LOCATION_SERVICE(geocoder), NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_set_p(void) +{ + if (available_key == NULL) { + available_key = strdup("test_key"); + available_value = strdup("test_value"); + } + int ret = location_preference_set(GET_LOCATION_SERVICE(geocoder), available_key, available_value); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_NONE, "location_preference_set failed."); +} + +static void utc_location_location_preference_set_n(void) +{ + int ret = location_preference_set(GET_LOCATION_SERVICE(geocoder), NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_get_p(void) +{ + int ret = 0; + char *value = NULL; + + ret = location_preference_get(GET_LOCATION_SERVICE(geocoder), available_key, &value); + if (value != NULL) { + tet_printf("value: %s", value); + } + + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_NONE, "location_preference_get failed."); +} + +static void utc_location_location_preference_get_n(void) +{ + int ret = location_preference_get(GET_LOCATION_SERVICE(geocoder), NULL, NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_get_provider_name_p(void) +{ + int ret = 0; + char *name = NULL; + + ret = location_preference_get_provider_name(GET_LOCATION_SERVICE(geocoder), &name); + + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + if (name != NULL) { + tet_printf("provider name: %s", name); + } + dts_pass(__func__, "location_preference_get_provider_name passed"); + } else + dts_fail(__func__, "location_preference_get_provider_name failed"); +} + +static void utc_location_location_preference_get_provider_name_n(void) +{ + int ret = location_preference_get_provider_name(GET_LOCATION_SERVICE(geocoder), NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_set_distance_unit_p(void) +{ + int ret = location_preference_set_distance_unit(GET_LOCATION_SERVICE(geocoder), LOCATION_PREFERENCE_DISTANCE_UNIT_FT); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_NONE, "location_preference_set_distance_unit failed."); +} + +static void utc_location_location_preference_set_distance_unit_n(void) +{ + int ret = location_preference_set_distance_unit(GET_LOCATION_SERVICE(geocoder), -1); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_get_distance_unit_p(void) +{ + int ret = 0; + location_preference_distance_unit_e unit = LOCATION_PREFERENCE_DISTANCE_UNIT_FT; + + ret = location_preference_get_distance_unit(GET_LOCATION_SERVICE(geocoder), &unit); + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + dts_pass(__func__, "location_preference_get_distance_unit passed"); + } else { + dts_fail(__func__, "location_preference_get_distance_unit failed"); + } +} + +static void utc_location_location_preference_get_distance_unit_n(void) +{ + int ret = location_preference_get_distance_unit(GET_LOCATION_SERVICE(geocoder), NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_set_language_p(void) +{ + if (available_language == NULL) { + available_language = strdup("KR"); + } + int ret = location_preference_set_language(GET_LOCATION_SERVICE(geocoder), available_language); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_NONE, "location_preference_set_language_unit failed."); +} + +static void utc_location_location_preference_set_language_n(void) +{ + int ret = location_preference_set_language(GET_LOCATION_SERVICE(geocoder), NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} + +static void utc_location_location_preference_get_language_p(void) +{ + int ret = 0; + char *language = NULL; + + ret = location_preference_get_language(GET_LOCATION_SERVICE(geocoder), &language); + if (ret == LOCATION_PREFERENCE_ERROR_NONE) { + dts_pass(__func__, "location_preference_get_distance_unit passed"); + } else { + dts_fail(__func__, "location_preference_get_distance_unit failed"); + } +} + +static void utc_location_location_preference_get_language_n(void) +{ + int ret = location_preference_get_language(GET_LOCATION_SERVICE(geocoder), NULL); + dts_check_eq(__func__, ret, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, + "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER was not returned."); +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100644 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100644 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100644 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/debian/changelog b/debian/changelog index 923732b..93548af 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,7 +1,84 @@ +capi-location-manager (0.1.2-1) unstable; urgency=low + + * Add location_manager_get_distance, location_preference_get_country_code and location_preference_set_country_code + * Tag: capi-location-manager_0.1.2-1 + + -- Minjune Kim Mon, 20 Aug 2012 17:03:51 +0900 + +capi-location-manager (0.1.1-2) unstable; urgency=low + + * Change the type of a parameter in location_manager_get_velocity and location_manager_get_last_velocity from int to double. + * Tag: capi-location-manager_0.1.1-2 + + -- Minjune Kim Mon, 13 Aug 2012 16:42:03 +0900 + +capi-location-manager (0.1.1-1) unstable; urgency=low + + * Support to muliple provider + * Tag: capi-location-manager_0.1.1-1 + + -- Minjune Kim Wed, 01 Aug 2012 10:29:48 +0900 + +capi-location-manager (0.1.0-26) unstable; urgency=low + + * Seperate map service from location service + * Tag: capi-location-manager_0.1.0-26 + + -- Minjune Kim Fri, 27 Jul 2012 20:11:48 +0900 + +capi-location-manager (0.1.0-25) unstable; urgency=low + + * Support developer mode + * Tag: capi-location-manager_0.1.0-25 + + -- Minjune Kim Thu, 19 Jul 2012 19:58:47 +0900 + +capi-location-manager (0.1.0-24) unstable; urgency=low + + * Add the env variable, LOCATION_TEST_ENABLE + * Tag: capi-location-manager_0.1.0-24 + + -- Minjune Kim Fri, 13 Jul 2012 13:50:04 +0900 + +capi-location-manager (0.1.0-23) unstable; urgency=low + + * Apply to the grammar check for locatoin_bounds_contains_coordinates() + * Tag: capi-location-manager_0.1.0-23 + + -- Kangho Hur Tue, 26 Jun 2012 22:36:13 +0900 + +capi-location-manager (0.1.0-22) unstable; urgency=low + + * Support LOCATION_METHOD_CPS & Remove LOCATIONS_METHOD_SPS + * Tag: capi-location-manager_0.1.0-22 + + -- Minjune Kim Fri, 25 May 2012 20:21:07 +0900 + +capi-location-manager (0.1.0-21) unstable; urgency=low + + * Support the satellte information updates + * LOCATION_METHOD_SPS is not supported. + * Tag: capi-location-manager_0.1.0-21 + + -- Minjune Kim Wed, 16 May 2012 12:32:07 +0900 + +capi-location-manager (0.1.0-20) unstable; urgency=low + + * Fix a bug that getting satellite was failed when a method was hybrid. + * Tag: capi-location-manager_0.1.0-20 + + -- Minjune Kim Wed, 09 May 2012 10:06:03 +0900 + +capi-location-manager (0.1.0-19) unstable; urgency=low + + * Resolve Gcc 4.6 warning + * Tag: capi-location-manager_0.1.0-19 + + -- Kangho Hur Fri, 20 Apr 2012 17:54:51 +0900 + capi-location-manager (0.1.0-18) unstable; urgency=low * Fix return value for location_bounds_is_contains_coordinates() - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-18 -- Minjune Kim Tue, 03 Apr 2012 11:24:16 +0900 @@ -9,7 +86,6 @@ capi-location-manager (0.1.0-18) unstable; urgency=low capi-location-manager (0.1.0-17) unstable; urgency=low * fixed TC results - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-17 -- Genie Kim Thu, 22 Mar 2012 17:22:01 +0900 @@ -17,7 +93,6 @@ capi-location-manager (0.1.0-17) unstable; urgency=low capi-location-manager (0.1.0-16) unstable; urgency=low * Correct bugs in location preference - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-16 -- ByungWoo Lee Tue, 20 Mar 2012 21:02:48 +0900 @@ -25,7 +100,6 @@ capi-location-manager (0.1.0-16) unstable; urgency=low capi-location-manager (0.1.0-15) unstable; urgency=low * Add location preference - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-15 -- ByungWoo Lee Mon, 19 Mar 2012 19:37:00 +0900 @@ -33,7 +107,6 @@ capi-location-manager (0.1.0-15) unstable; urgency=low capi-location-manager (0.1.0-14) unstable; urgency=low * change gps_status_get_satellite functions - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-14 -- Genie Kim Wed, 14 Mar 2012 20:41:44 +0900 @@ -41,7 +114,6 @@ capi-location-manager (0.1.0-14) unstable; urgency=low capi-location-manager (0.1.0-13) unstable; urgency=low * Remove the unneccesary structure (location_bounds_s) - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-13 -- Kangho Hur Tue, 13 Mar 2012 16:03:12 +0900 @@ -49,7 +121,6 @@ capi-location-manager (0.1.0-13) unstable; urgency=low capi-location-manager (0.1.0-12) unstable; urgency=low * Add the last position, velocity, accuracy and satellite - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-12 -- Genie Kim Thu, 08 Mar 2012 14:56:28 +0900 @@ -57,7 +128,6 @@ capi-location-manager (0.1.0-12) unstable; urgency=low capi-location-manager (0.1.0-11) unstable; urgency=low * Support to multiple boundaries - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-11 -- Kangho Hur Tue, 06 Mar 2012 20:21:26 +0900 @@ -65,7 +135,6 @@ capi-location-manager (0.1.0-11) unstable; urgency=low capi-location-manager (0.1.0-10) unstable; urgency=low * Add the location_bounds. - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-10 -- Kangho Hur Fri, 02 Mar 2012 20:52:01 +0900 @@ -73,7 +142,6 @@ capi-location-manager (0.1.0-10) unstable; urgency=low capi-location-manager (0.1.0-9) unstable; urgency=low * Use 'static' to local function which is limited to the current source file. - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-9 -- Kangho Hur Tue, 21 Feb 2012 10:11:16 +0900 @@ -81,7 +149,6 @@ capi-location-manager (0.1.0-9) unstable; urgency=low capi-location-manager (0.1.0-8) unstable; urgency=low * Apply the SOVERSION - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-8 -- Kangho Hur Tue, 14 Feb 2012 17:53:09 +0900 @@ -89,7 +156,6 @@ capi-location-manager (0.1.0-8) unstable; urgency=low capi-location-manager (0.1.0-7) unstable; urgency=low * Add the location_manager_get_last_known_position(), location_manager_is_supported_method(), and interval setting. - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-7 -- Kangho Hur Thu, 26 Jan 2012 20:08:56 +0900 @@ -97,7 +163,6 @@ capi-location-manager (0.1.0-7) unstable; urgency=low capi-location-manager (0.1.0-6) unstable; urgency=low * Apply Location Boundary changes - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-6 -- Kangho Hur Wed, 07 Dec 2011 11:44:27 +0900 @@ -105,7 +170,6 @@ capi-location-manager (0.1.0-6) unstable; urgency=low capi-location-manager (0.1.0-5) unstable; urgency=low * Changes the value of ERROR_NONE - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-5 -- Kangho Hur Mon, 05 Dec 2011 11:18:34 +0900 @@ -113,7 +177,6 @@ capi-location-manager (0.1.0-5) unstable; urgency=low capi-location-manager (0.1.0-4) unstable; urgency=low * Apply the Tizen - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-4 -- Kangho Hur Wed, 23 Nov 2011 15:09:01 +0900 @@ -121,7 +184,6 @@ capi-location-manager (0.1.0-4) unstable; urgency=low capi-location-manager (0.1.0-3) unstable; urgency=low * Repackage for SDK - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-3 -- Kangho Hur Mon, 07 Nov 2011 21:40:30 +0900 @@ -129,7 +191,6 @@ capi-location-manager (0.1.0-3) unstable; urgency=low capi-location-manager (0.1.0-2) unstable; urgency=low * Apply the error messages - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-2 -- Kangho Hur Fri, 07 Oct 2011 13:28:33 +0900 @@ -137,7 +198,6 @@ capi-location-manager (0.1.0-2) unstable; urgency=low capi-location-manager (0.1.0-1) unstable; urgency=low * Alpha Release - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.1.0-1 -- Kangho Hur Tue, 27 Sep 2011 20:03:39 +0900 @@ -145,7 +205,6 @@ capi-location-manager (0.1.0-1) unstable; urgency=low capi-location-manager (0.0.1-5) unstable; urgency=low * Add the location_manager_is_boundary_contains_coordinate() - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.0.1-5 -- Kangho Hur Mon, 26 Sep 2011 19:41:49 +0900 @@ -153,7 +212,6 @@ capi-location-manager (0.0.1-5) unstable; urgency=low capi-location-manager (0.0.1-4) unstable; urgency=low * gps_status_get_used_satellite_count() API name changes. - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.0.1-4 -- Kangho Hur Fri, 09 Sep 2011 16:58:25 +0900 @@ -161,7 +219,6 @@ capi-location-manager (0.0.1-4) unstable; urgency=low capi-location-manager (0.0.1-3) unstable; urgency=low * Remove IPS, CPS location method type - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.0.1-3 -- Kangho Hur Mon, 05 Sep 2011 14:19:50 +0900 @@ -169,7 +226,6 @@ capi-location-manager (0.0.1-3) unstable; urgency=low capi-location-manager (0.0.1-2) unstable; urgency=low * Rename the callback prototype - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.0.1-2 -- Kangho Hur Mon, 08 Aug 2011 10:15:11 +0900 @@ -177,7 +233,6 @@ capi-location-manager (0.0.1-2) unstable; urgency=low capi-location-manager (0.0.1-1) unstable; urgency=low * Initial Upload - * Git: slp-source.sec.samsung.net:slp/api/location-manager * Tag: capi-location-manager_0.0.1-1 -- Kangho Hur Thu, 04 Aug 2011 16:51:02 +0900 diff --git a/include/location_bounds.h b/include/location_bounds.h index 59ee72c..08146fc 100644 --- a/include/location_bounds.h +++ b/include/location_bounds.h @@ -134,7 +134,7 @@ int location_bounds_create_polygon(location_coords_s* coords_list, int length, l * @see location_bounds_create_circle() * @see location_bounds_create_polygon() */ -bool location_bounds_is_contains_coordinates(location_bounds_h bounds, location_coords_s coords); +bool location_bounds_contains_coordinates(location_bounds_h bounds, location_coords_s coords); /** * @brief Get the type of location bounds. diff --git a/include/location_preference.h b/include/location_preference.h index 29d44e4..c7a755b 100644 --- a/include/location_preference.h +++ b/include/location_preference.h @@ -108,6 +108,16 @@ typedef bool (*location_preference_available_language_cb)(const char* language, typedef bool (*location_preference_property_cb)(const char* key, const char* value, void* user_data); /** + * @brief Called repeatedly to get each supported providers. + * @param[in] provider The supported provider name + * @param[in] user_data The user data passed from the foreach function + * @return @c true to continue with the next iteration of the loop, \n @c false to break outsp of the loop. + * @pre location_preference_foreach_supported_provider() will invoke this callback. + * @see location_preference_foreach_supported_provider() + */ +typedef bool (*location_preference_supported_provider_cb)(const char* provider, void *user_data); + +/** * @brief Retrieves the available property keys of location preference. * @param[in] location_service The memory pointer of location service handle. * It must be converted into location_service_h by GET_LOCATION_SERVICE(). @@ -207,8 +217,23 @@ int location_preference_set(location_service_h service, const char* key, const c */ int location_preference_get(location_service_h service, const char* key, char** value); +__attribute__ ((deprecated)) int location_preference_get_provider_name(location_service_h service, char** provider); + /** - * @brief Gets the provider name of location service. + * @brief Sets the provider of location service. + * @param[in] location_service The memory pointer of location service handle. + * It must be converted into location_service_h by GET_LOCATION_SERVICE(). + * @param[in] provider The provider name of location service + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful + * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter + * @see GET_LOCATION_SERVICE() + * @see location_preference_get_provider() + */ +int location_preference_set_provider(location_service_h service, char* provider); + +/** + * @brief Gets the provider of location service. * @remarks The @a provider must be released with free() by you. * @param[in] location_service The memory pointer of location service handle. * It must be converted into location_service_h by GET_LOCATION_SERVICE(). @@ -216,9 +241,38 @@ int location_preference_get(location_service_h service, const char* key, char** * @return 0 on success, otherwise a negative error value. * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter + * @see GET_LOCATION_SERVICE() + * @see location_preference_set_provider() + */ +int location_preference_get_provider(location_service_h service, char** provider); + +/** + * @brief Gets the default provider of location service. + * @remarks The @a provider must be released with free() by you. + * @param[in] location_service The memory pointer of location service handle. + * It must be converted into location_service_h by GET_LOCATION_SERVICE(). + * @param[out] provider The default provider name of location service + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful + * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter * @see GET_LOCATION_SERVICE() */ -int location_preference_get_provider_name(location_service_h service, char** provider); +int location_preference_get_default_provider(location_service_h service, char** provider); + +/** + * @brief Gets the provider of location service. + * @param[in] location_service The memory pointer of location service handle. + * It must be converted into location_service_h by GET_LOCATION_SERVICE(). + * @param[in] callback The callback function to be invoked + * @param[in] user_data The user data passed to the callback function + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful + * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter + * @post This function invokes location_preference_supported_provider_cb() to get all supported providers. + * @see GET_LOCATION_SERVICE() + * @see location_preference_set_provider() + */ +int location_preference_foreach_supported_provider(location_service_h service, location_preference_supported_provider_cb callback , void *user_data); /** * @brief Gets the distance unit of location service. @@ -274,6 +328,32 @@ int location_preference_get_language(location_service_h service, char** language int location_preference_set_language(location_service_h service, const char* language); /** + * @brief Sets the country code. + * @param[in] location_service The memory pointer of location service handle. + * It must be converted into location_service_h by GET_LOCATION_SERVICE(). + * @param[in] country_code The country code + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful + * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter + * @see GET_LOCATION_SERVICE() + * @see location_preference_get_country_code() + */ +int location_preference_set_country_code(location_service_h service, const char* country_code); + +/** + * @brief Gets the country code. + * @param[in] location_service The memory pointer of location service handle. + * It must be converted into location_service_h by GET_LOCATION_SERVICE(). + * @param[out] country_code The country code + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATION_PREFERENCE_ERROR_NONE Successful + * @retval #LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER Invalid parameter + * @see GET_LOCATION_SERVICE() + * @see location_preference_set_country_code() + */ +int location_preference_get_country_code(location_service_h service, char** country_code); + +/** * @} */ diff --git a/include/locations.h b/include/locations.h index 9d9cfcb..89d4b77 100644 --- a/include/locations.h +++ b/include/locations.h @@ -55,7 +55,7 @@ typedef enum LOCATIONS_METHOD_HYBRID, /**< This method selects the best method available at the moment. */ LOCATIONS_METHOD_GPS, /**< This method uses Global Positioning System. */ LOCATIONS_METHOD_WPS, /**< This method uses Wifi Positioning System. */ - LOCATIONS_METHOD_SPS /**< This method uses sensor. */ + LOCATIONS_METHOD_CPS /**< This method uses Cellular Positioning System. */ } location_method_e; /** @@ -106,11 +106,11 @@ typedef enum * @{ */ /** - * @brief Called every 1 second with updated position information. + * @brief Called at defined interval with updated position information. * @param[in] latitude The updated latitude [-90.0 ~ 90.0] (degrees) * @param[in] longitude The updated longitude [-180.0 ~ 180.0] (degrees) * @param[in] altitude The updated altitude (meters) - * @param[in] timestamp The timestamp (time when measurement took place) + * @param[in] timestamp The timestamp (time when measurement took place or 0 if invalid) * @param[in] user_data The user data passed from the call registration function * @pre location_manager_start() will invoke this callback if you register this callback using location_manager_set_position_updated_cb() * @see location_manager_start() @@ -119,11 +119,11 @@ typedef enum typedef void(*location_position_updated_cb)(double latitude, double longitude, double altitude, time_t timestamp, void *user_data); /** - * @brief Called every 1 second with updated velocity information. + * @brief Called at defined interval with updated velocity information. * @param[in] speed The updated speed (km/h) * @param[in] direction The updated direction (in degrees from the north) * @param[in] climb The updated climb (km/h) - * @param[in] timestamp The timestamp (time when measurement took place) + * @param[in] timestamp The timestamp (time when measurement took place or 0 if invalid) * @param[in] user_data The user data passed from the callback registration function * @pre location_manager_start() will invoke this callback if you register this callback using location_manager_set_velocity_updated_cb() * @see location_manager_start() @@ -149,7 +149,7 @@ typedef void(*location_service_state_changed_cb)(location_service_state_e state, * @param[in] latitude The updated latitude [-90.0 ~ 90.0] (degrees) * @param[in] longitude The updated longitude [-180.0 ~ 180.0] (degrees) * @param[in] altitude The updated altitude (meters) - * @param[in] timestamp The timestamp (time when measurement took place) + * @param[in] timestamp The timestamp (time when measurement took place or 0 if invalid) * @param[in] user_data The user data passed from the callback registration function * @pre location_manager_start() will invoke this callback if you register this callback using location_manager_set_zone_changed_cb() * @see #location_boundary_state_e @@ -328,7 +328,7 @@ int location_manager_get_method(location_manager_h manager, location_method_e *m * @param[out] altitude The current altitude (meters) * @param[out] latitude The current latitude [-90.0 ~ 90.0] (degrees) * @param[out] longitude The current longitude [-180.0 ~ 180.0] (degrees) - * @param[out] timestamp The timestamp (time when measurement took place) + * @param[out] timestamp The timestamp (time when measurement took place or 0 if valid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument @@ -347,7 +347,7 @@ int location_manager_get_position(location_manager_h manager, double *altitude, * @param[out] climb The climb (km/h) * @param[out] direction The direction, degrees from the north * @param[out] speed The speed (km/h) - * @param[out] timestamp The timestamp (time when measurement took place) + * @param[out] timestamp The timestamp (time when measurement took place or 0 if invalid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument @@ -355,7 +355,7 @@ int location_manager_get_position(location_manager_h manager, double *altitude, * @retval #LOCATIONS_ERROR_GPS_SETTING_OFF GPS is not enabled * @pre The location service state must be #LOCATIONS_SERVICE_ENABLED with location_manager_start() */ -int location_manager_get_velocity(location_manager_h manager, int *climb, int *direction, int *speed, time_t *timestamp); +int location_manager_get_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t *timestamp); /** * @brief Gets the current accuracy information. @@ -381,7 +381,7 @@ int location_manager_get_accuracy(location_manager_h manager, location_accuracy_ * @param[out] altitude The last altitude (meters) * @param[out] latitude The last latitude [-90.0 ~ 90.0] (degrees) * @param[out] longitude The last longitude [-180.0 ~ 180.0] (degrees) - * @param[out] timestamp The timestamp (time when measurement took place) + * @param[out] timestamp The timestamp (time when measurement took place or 0 if invalid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument @@ -398,13 +398,13 @@ int location_manager_get_last_position(location_manager_h manager, double *altit * @param[out] climb The last climb (km/h) * @param[out] direction The last direction, degrees from the north * @param[out] speed The last speed (km/h) - * @param[out] timestamp The timestamp (time when measurement took place) + * @param[out] timestamp The timestamp (time when measurement took place or 0 if invalid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument * @pre The location manager handle must be created by location_manager_create() */ -int location_manager_get_last_velocity(location_manager_h manager, int *climb, int *direction, int *speed, time_t *timestamp); +int location_manager_get_last_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t *timestamp); /** * @brief Gets the last accuracy information which is recorded. @@ -420,7 +420,7 @@ int location_manager_get_last_velocity(location_manager_h manager, int *climb, i int location_manager_get_last_accuracy(location_manager_h manager, location_accuracy_level_e *level, double *horizontal, double *vertical); /** - * @brief Registers a callback function to be invoked every 1 second with updated position information. + * @brief Registers a callback function to be invoked at defined interval with updated position information. * * @param[in] manager The location manager handle * @param[in] callback The callback function to register @@ -433,7 +433,7 @@ int location_manager_get_last_accuracy(location_manager_h manager, location_accu * @see location_manager_unset_position_updated_cb() * @see location_position_updated_cb() */ -int location_manager_set_position_updated_cb(location_manager_h manager, location_position_updated_cb callback, int interval, void *user_data); +int location_manager_set_position_updated_cb(location_manager_h manager, location_position_updated_cb callback, int interval, void *user_data); /** * @brief Unregisters the callback function. @@ -447,10 +447,11 @@ int location_manager_set_position_updated_cb(location_manager_h manager, locatio int location_manager_unset_position_updated_cb(location_manager_h manager); /** - * @brief Registers a callback function to be invoked every 1 second with updated velocity information. + * @brief Registers a callback function to be invoked at defined interval with updated velocity information. * * @param[in] manager The location manager handle * @param[in] callback The callback function to register + * @param[in] interval The interval [1 ~ 120] (seconds) * @param[in] user_data The user data to be passed to the callback function * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful @@ -459,7 +460,7 @@ int location_manager_unset_position_updated_cb(location_manager_h manager); * @see location_manager_unset_velocity_updated_cb() * @see location_velocity_updated_cb() */ -int location_manager_set_velocity_updated_cb(location_manager_h manager, location_velocity_updated_cb callback, void *user_data); +int location_manager_set_velocity_updated_cb(location_manager_h manager, location_velocity_updated_cb callback, int interval, void *user_data); /** * @brief Unregisters the callback function. @@ -527,6 +528,19 @@ int location_manager_set_zone_changed_cb(location_manager_h manager, location_zo int location_manager_unset_zone_changed_cb(location_manager_h manager); /** + * @brief Gets the distance in meters between two locations. + * @param[in] start_latitude The starting latitude [-90.0 ~ 90.0] (degrees) + * @param[in] start_longitude The starting longitude [-180.0 ~ 180.0] (degrees) + * @param[in] end_latitude The ending latitude [-90.0 ~ 90.0] (degrees) + * @param[in] end_longitude The ending longitude [-180.0 ~ 180.0] (degrees) + * @param[out] distance The distance between two locations (meters) + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATIONS_ERROR_NONE Successful + * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument + */ +int location_manager_get_distance(double start_latitude, double start_longitude, double end_latitude, double end_longitude, double *distance); + +/** * @brief Sends command to the server. * @param[in] cmd The command string to be sent * @return 0 on success, otherwise a negative error value. @@ -564,6 +578,18 @@ int location_manager_send_command(const char *cmd); typedef bool(*gps_status_get_satellites_cb)(unsigned int azimuth, unsigned int elevation, unsigned int prn, int snr, bool is_active, void *user_data); /** + * @brief Called at defined interval with updated satellite information. + * @param[out] num_of_active The last number of active satellites + * @param[out] num_of_inview The last number of satellites in view + * @param[out] timestamp The last timestamp (time when last measurement took place or 0 if invalid) + * @param[in] user_data The user data passed from the call registration function + * @pre location_manager_start() will invoke this callback if you register this callback using location_manager_set_position_updated_cb() + * @see location_manager_start() + * @see location_manager_set_position_updated_cb() + */ +typedef void(*gps_status_satellite_updated_cb)(int num_of_active, int num_of_inview, time_t timestamp, void *user_data); + +/** * @brief Gets the GPS NMEA data. * @remarks This call is valid only for location managers with #LOCATIONS_METHOD_GPS method.\n * @a nmea must be released with @c free() by you. @@ -586,7 +612,7 @@ int gps_status_get_nmea(location_manager_h manager, char **nmea); * @param[in] manager The location manager handle * @param[out] num_of_active The number of active satellites * @param[out] num_of_inview The number of satellites in view - * @param[out] timestamp The timestamp (time when measurement took place) + * @param[out] timestamp The timestamp (time when measurement took place or 0 if invalid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument @@ -598,6 +624,33 @@ int gps_status_get_nmea(location_manager_h manager, char **nmea); int gps_status_get_satellite(location_manager_h manager, int *num_of_active, int *num_of_inview, time_t *timestamp); /** + * @brief Registers a callback function to be invoked at defined interval with updated satellite information. + * + * @param[in] manager The location manager handle + * @param[in] callback The callback function to register + * @param[in] interval The interval [1 ~ 120] (seconds) + * @param[in] user_data The user data to be passed to the callback function + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATIONS_ERROR_NONE Successful + * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid parameter + * @post gps_status_satellite_updated_cb() will be invoked + * @see gps_status_unset_satellite_updated_cb() + * @see gps_status_satellite_updated_cb() + */ +int gps_status_set_satellite_updated_cb(location_manager_h manager, gps_status_satellite_updated_cb callback, int interval, void *user_data); + +/** + * @brief Unregisters the callback function. + * + * @param[in] manager The location manager handle + * @return 0 on success, otherwise a negative error value. + * @retval #LOCATIONS_ERROR_NONE Successful + * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid parameter + * @see gps_status_set_satellite_updated_cb() + */ +int gps_status_unset_satellite_updated_cb(location_manager_h manager); + +/** * @brief Invokes the callback function for each satellite. * @remarks This function is valid only for location managers with the #LOCATIONS_METHOD_GPS method. * @param[in] manager The location manager handle @@ -621,7 +674,7 @@ int gps_status_foreach_satellites_in_view (location_manager_h manager, gps_stat * @param[in] manager The location manager handle * @param[out] num_of_active The last number of active satellites * @param[out] num_of_inview The last number of satellites in view - * @param[out] timestamp The last timestamp (time when last measurement took place) + * @param[out] timestamp The last timestamp (time when last measurement took place or 0 if invalid) * @return 0 on success, otherwise a negative error value. * @retval #LOCATIONS_ERROR_NONE Successful * @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument diff --git a/include/locations_private.h b/include/locations_private.h index cdcde84..5874856 100644 --- a/include/locations_private.h +++ b/include/locations_private.h @@ -30,6 +30,7 @@ typedef enum { _LOCATIONS_EVENT_TYPE_POSITION, _LOCATIONS_EVENT_TYPE_VELOCITY, _LOCATIONS_EVENT_TYPE_BOUNDARY, + _LOCATIONS_EVENT_TYPE_SATELLITE, _LOCATIONS_EVENT_TYPE_FOREACH_BOUNDS, _LOCATIONS_EVENT_TYPE_NUM }_location_event_e; diff --git a/packaging/capi-location-manager.spec b/packaging/capi-location-manager.spec index c17a93d..f719a6c 100644 --- a/packaging/capi-location-manager.spec +++ b/packaging/capi-location-manager.spec @@ -1,9 +1,10 @@ +#sbs-git:slp/api/location-manager capi-location-manager 0.1.0 d1ee09a32e8bc0e9ed48ece37c641a7393c086c5 Name: capi-location-manager Summary: A Location Manager library in Tizen Native API -Version: 0.1.0 -Release: 17 +Version: 0.1.2 +Release: 1 Group: TO_BE/FILLED_IN -License: Apache-2.0 +License: TO BE FILLED IN Source0: %{name}-%{version}.tar.gz BuildRequires: cmake BuildRequires: pkgconfig(dlog) diff --git a/src/location_bounds.c b/src/location_bounds.c index caf66cd..cdcaae7 100644 --- a/src/location_bounds.c +++ b/src/location_bounds.c @@ -48,16 +48,17 @@ static location_bounds_type_e __convert_bounds_type(LocationBoundaryType type) location_bounds_type_e ret; switch(type) { - case LOCATION_BOUNDARY_NONE: - case LOCATION_BOUNDARY_RECT: - ret = LOCATION_BOUNDS_RECT; - break; case LOCATION_BOUNDARY_CIRCLE: ret = LOCATION_BOUNDS_CIRCLE; break; case LOCATION_BOUNDARY_POLYGON: ret = LOCATION_BOUNDS_POLYGON; break; + case LOCATION_BOUNDARY_NONE: + case LOCATION_BOUNDARY_RECT: + default: + ret = LOCATION_BOUNDS_RECT; + break; } return ret; } @@ -176,7 +177,7 @@ int location_bounds_create_polygon(location_coords_s* coords_list, int length, l return LOCATION_BOUNDS_ERROR_NONE; } -bool location_bounds_is_contains_coordinates(location_bounds_h bounds, location_coords_s coords) +bool location_bounds_contains_coordinates(location_bounds_h bounds, location_coords_s coords) { if (!bounds) return FALSE; @@ -187,7 +188,6 @@ bool location_bounds_is_contains_coordinates(location_bounds_h bounds, location_ LocationPosition *pos = location_position_new(0, coords.latitude, coords.longitude, 0, LOCATION_STATUS_2D_FIX); if (!pos) return FALSE; - gboolean is_inside = location_boundary_if_inside((LocationBoundary*)bounds, pos); location_position_free (pos); bool result = is_inside?TRUE:FALSE; diff --git a/src/location_preference.c b/src/location_preference.c index 64ca623..9ae11bb 100644 --- a/src/location_preference.c +++ b/src/location_preference.c @@ -16,7 +16,7 @@ #include #include -#include +#include #include #include @@ -38,7 +38,7 @@ #define LOCATION_PREFERENCE_PRINT_ERROR_CODE(error, msg) \ LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg, error); return error; -#define LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service) *((LocationObject**)service) +#define LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service) *((LocationMapObject**)service) /* @@ -77,7 +77,7 @@ static int __convert_error_code(int code, char* func_name) */ int location_preference_foreach_available_property_keys(location_service_h service, location_preference_available_property_key_cb callback, void* user_data) { - LocationObject* object = NULL; + LocationMapObject* object = NULL; GList* keys = NULL; char* key = NULL; int ret = 0; @@ -86,7 +86,7 @@ int location_preference_foreach_available_property_keys(location_service_h servi LOCATION_PREFERENCE_NULL_ARG_CHECK(callback); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - ret = location_get_map_provider_capability_key(object, MAP_SERVICE_PREF_PROPERTY, &keys); + ret = location_map_get_provider_capability_key(object, MAP_SERVICE_PREF_PROPERTY, &keys); if(ret != LOCATION_ERROR_NONE) { return __convert_error_code(ret, (char*)__FUNCTION__); @@ -114,7 +114,7 @@ int location_preference_foreach_available_property_values(location_service_h ser int location_preference_foreach_available_languages(location_service_h service, location_preference_available_language_cb callback, void* user_data) { - LocationObject* object = NULL; + LocationMapObject* object = NULL; GList* keys = NULL; char* key = NULL; int ret = 0; @@ -123,7 +123,7 @@ int location_preference_foreach_available_languages(location_service_h service, LOCATION_PREFERENCE_NULL_ARG_CHECK(callback); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - ret = location_get_map_provider_capability_key(object, MAP_SERVICE_PREF_LANGUAGE, &keys); + ret = location_map_get_provider_capability_key(object, MAP_SERVICE_PREF_LANGUAGE, &keys); if(ret != LOCATION_ERROR_NONE) { return __convert_error_code(ret, (char*)__FUNCTION__); @@ -144,8 +144,8 @@ int location_preference_foreach_available_languages(location_service_h service, int location_preference_foreach_properties(location_service_h service, location_preference_property_cb callback, void* user_data) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; GList* keys = NULL; char* key = NULL; char* value = NULL; @@ -154,46 +154,46 @@ int location_preference_foreach_properties(location_service_h service, location_ LOCATION_PREFERENCE_NULL_ARG_CHECK(callback); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - keys = location_pref_get_property_key(pref); + keys = location_map_pref_get_property_key(pref); while(keys) { key = keys->data; - value = (char*)location_pref_get_property(pref, key); + value = (char*)location_map_pref_get_property(pref, key); if(!callback(key, value, user_data)) break; keys = keys->next; } - location_pref_free(pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_set(location_service_h service, const char* key, const char* value) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); LOCATION_PREFERENCE_NULL_ARG_CHECK(key); LOCATION_PREFERENCE_NULL_ARG_CHECK(value); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - location_pref_set_property(pref, (gconstpointer)key, (gconstpointer)value); - location_set_map_service_pref(object, pref); - location_pref_free(pref); + location_map_pref_set_property(pref, (gconstpointer)key, (gconstpointer)value); + location_map_set_service_pref(object, pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_get(location_service_h service, const char* key, char** value) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; char* ret = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); @@ -201,61 +201,154 @@ int location_preference_get(location_service_h service, const char* key, char** LOCATION_PREFERENCE_NULL_ARG_CHECK(value); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - ret = (char*)location_pref_get_property(pref, (gconstpointer)key); + ret = (char*)location_map_pref_get_property(pref, (gconstpointer)key); if(ret != NULL) { *value = strdup(ret); - location_pref_free(pref); - return LOCATION_PREFERENCE_ERROR_NONE; + location_map_pref_free(pref); } else { *value = NULL; - location_pref_free(pref); + location_map_pref_free(pref); LOCATION_PREFERENCE_PRINT_ERROR_CODE(LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_KEY"); } + + return LOCATION_PREFERENCE_ERROR_NONE; +} + +int location_preference_set_provider(location_service_h service, char* provider) +{ + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(provider); + + LocationMapObject *object = NULL; + LocationMapPref *pref = NULL; + gboolean ret = FALSE; + + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + pref = location_map_get_service_pref(object); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + + ret = location_map_pref_set_provider_name(pref, provider); + if (!ret) { + location_map_pref_free(pref); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + } + ret = location_map_set_service_pref(object, pref); + if (!ret) { + location_map_pref_free(pref); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + } + + location_map_pref_free(pref); + return LOCATION_PREFERENCE_ERROR_NONE; +} + +int location_preference_get_provider(location_service_h service, char** provider) +{ + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(provider); + + LocationMapObject *object = NULL; + LocationMapPref *pref = NULL; + gchar* current_provider = NULL; + + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + pref = location_map_get_service_pref(object); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + + current_provider = location_map_pref_get_provider_name(pref); + if (!current_provider) { + location_map_pref_free(pref); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + } + + *provider = g_strdup (current_provider); + location_map_pref_free(pref); + + return LOCATION_PREFERENCE_ERROR_NONE; +} + +int location_preference_get_default_provider(location_service_h service, char** provider) +{ + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(provider); + + LocationMapObject *object = NULL; + gchar *current_provider = NULL; + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + current_provider = location_map_get_default_provider(object); + LOCATION_PREFERENCE_CHECK_CONDITION(current_provider != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + + *provider = g_strdup(current_provider); + g_free(current_provider); + + return LOCATION_PREFERENCE_ERROR_NONE; +} + +int location_preference_foreach_supported_provider(location_service_h service, location_preference_supported_provider_cb callback , void *user_data) +{ + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(callback); + + LocationMapObject *object = NULL; + GList *providers = NULL; + gchar *provider = NULL; + + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + providers = location_map_get_supported_providers(object); + LOCATION_PREFERENCE_CHECK_CONDITION(providers != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + while(providers) { + provider = providers->data; + if(!callback(provider, user_data)) + break; + providers = providers->next; + } + + return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_get_provider_name(location_service_h service, char** provider) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; char* ret = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); LOCATION_PREFERENCE_NULL_ARG_CHECK(provider); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - ret = location_pref_get_provider_name(pref); + ret = location_map_pref_get_provider_name(pref); if(ret != NULL) *provider = strdup(ret); else *provider = NULL; - location_pref_free(pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_get_distance_unit(location_service_h service, location_preference_distance_unit_e* unit) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; char* ret = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); LOCATION_PREFERENCE_NULL_ARG_CHECK(unit); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - ret = location_pref_get_distance_unit(pref); + ret = location_map_pref_get_distance_unit(pref); if(ret != NULL) { switch(ret[0]) { @@ -275,20 +368,20 @@ int location_preference_get_distance_unit(location_service_h service, location_p *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_M; break; } - location_pref_free(pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } else { - location_pref_free(pref); + location_map_pref_free(pref); LOCATION_PREFERENCE_PRINT_ERROR_CODE(LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND, "LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND"); } } int location_preference_set_distance_unit(location_service_h service, location_preference_distance_unit_e unit) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; char* distance = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); @@ -313,56 +406,97 @@ int location_preference_set_distance_unit(location_service_h service, location_p } object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - location_pref_set_distance_unit(pref, distance); - location_set_map_service_pref(object, pref); - location_pref_free(pref); + location_map_pref_set_distance_unit(pref, distance); + location_map_set_service_pref(object, pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_get_language(location_service_h service, char** language) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; char* ret = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); LOCATION_PREFERENCE_NULL_ARG_CHECK(language); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - ret = location_pref_get_language(pref); + ret = location_map_pref_get_language(pref); if(ret != NULL) *language = strdup(ret); else *language = NULL; - location_pref_free(pref); + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } int location_preference_set_language(location_service_h service, const char* language) { - LocationPreference* pref = NULL; - LocationObject* object = NULL; + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; LOCATION_PREFERENCE_NULL_ARG_CHECK(service); LOCATION_PREFERENCE_NULL_ARG_CHECK(language); object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); - pref = location_get_map_service_pref(object); + pref = location_map_get_service_pref(object); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + + location_map_pref_set_language(pref, language); + location_map_set_service_pref(object, pref); + location_map_pref_free(pref); + + return LOCATION_PREFERENCE_ERROR_NONE; +} + + +int location_preference_get_country_code(location_service_h service, char** country_code) +{ + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; + char* ret = NULL; + + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(country_code); + + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + pref = location_map_get_service_pref(object); LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); - location_pref_set_language(pref, language); - location_set_map_service_pref(object, pref); - location_pref_free(pref); + ret = location_map_pref_get_country(pref); + if(ret != NULL) + *country_code = strdup(ret); + else + *country_code = NULL; + location_map_pref_free(pref); return LOCATION_PREFERENCE_ERROR_NONE; } +int location_preference_set_country_code(location_service_h service, const char* country_code) +{ + LocationMapPref* pref = NULL; + LocationMapObject* object = NULL; + + LOCATION_PREFERENCE_NULL_ARG_CHECK(service); + LOCATION_PREFERENCE_NULL_ARG_CHECK(country_code); + object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service); + pref = location_map_get_service_pref(object); + LOCATION_PREFERENCE_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER"); + + location_map_pref_set_country(pref, country_code); + location_map_set_service_pref(object, pref); + location_map_pref_free(pref); + + return LOCATION_PREFERENCE_ERROR_NONE; +} diff --git a/src/locations.c b/src/locations.c index 7667808..bf1b50a 100644 --- a/src/locations.c +++ b/src/locations.c @@ -82,7 +82,7 @@ static void __cb_service_updated(GObject * self, guint type, gpointer data, gpoi handle->user_data [_LOCATIONS_EVENT_TYPE_VELOCITY]); } - if (type == POSITION_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION]) { + else if (type == POSITION_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION]) { LocationPosition *pos = (LocationPosition *) data; LOGI("[%s] Current position: timestamp : %d, latitude : %f, altitude: %f, longitude: %f", __FUNCTION__, pos->timestamp, pos->latitude, pos->altitude, pos->longitude); @@ -91,6 +91,13 @@ static void __cb_service_updated(GObject * self, guint type, gpointer data, gpoi handle->user_data [_LOCATIONS_EVENT_TYPE_POSITION]); } + else if (type == SATELLITE_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE]) { + LocationSatellite *sat = (LocationSatellite *)data; + LOGI("[%s] Current satellite information: timestamp : %d, number of active : %d, number of inview : %d", __FUNCTION__, + sat->timestamp, sat->num_of_sat_used, sat->num_of_sat_inview); + ((gps_status_satellite_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE]) (sat->num_of_sat_used, sat->num_of_sat_inview, + sat->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_SATELLITE]); + } } static void __cb_service_enabled(GObject * self, guint status, gpointer userdata) @@ -238,8 +245,8 @@ bool location_manager_is_supported_method(location_method_e method) case LOCATIONS_METHOD_WPS: _method = LOCATION_METHOD_WPS; break; - case LOCATIONS_METHOD_SPS: - _method = LOCATION_METHOD_SPS; + case LOCATIONS_METHOD_CPS: + _method = LOCATION_METHOD_CPS; break; default: _method = LOCATION_METHOD_NONE; @@ -256,9 +263,6 @@ int location_manager_create(location_method_e method, location_manager_h * manag LocationMethod _method = LOCATION_METHOD_NONE; switch (method) { - case LOCATIONS_METHOD_NONE: - _method = LOCATION_METHOD_NONE; - break; case LOCATIONS_METHOD_HYBRID: _method = LOCATION_METHOD_HYBRID; break; @@ -268,9 +272,11 @@ int location_manager_create(location_method_e method, location_manager_h * manag case LOCATIONS_METHOD_WPS: _method = LOCATION_METHOD_WPS; break; - case LOCATIONS_METHOD_SPS: - _method = LOCATION_METHOD_SPS; + case LOCATIONS_METHOD_CPS: + _method = LOCATION_METHOD_CPS; break; + case LOCATIONS_METHOD_NONE: + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; default: { LOGE("[%s] LOCATIONS_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (location_method_e) - method : %d ", @@ -399,8 +405,6 @@ int location_manager_get_method(location_manager_h manager, location_method_e * *method = LOCATIONS_METHOD_NONE; break; case LOCATION_METHOD_HYBRID: - case LOCATION_METHOD_CPS: - case LOCATION_METHOD_IPS: *method = LOCATIONS_METHOD_HYBRID; break; case LOCATION_METHOD_GPS: @@ -409,8 +413,8 @@ int location_manager_get_method(location_manager_h manager, location_method_e * case LOCATION_METHOD_WPS: *method = LOCATIONS_METHOD_WPS; break; - case LOCATION_METHOD_SPS: - *method = LOCATIONS_METHOD_SPS; + case LOCATION_METHOD_CPS: + *method = LOCATIONS_METHOD_CPS; break; default: { @@ -460,7 +464,7 @@ int location_manager_get_position(location_manager_h manager, double *altitude, return LOCATIONS_ERROR_NONE; } -int location_manager_get_velocity(location_manager_h manager, int *climb, int *direction, int *speed, time_t * timestamp) +int location_manager_get_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t * timestamp) { LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(climb); @@ -549,7 +553,7 @@ int location_manager_get_last_position(location_manager_h manager, double *altit return LOCATIONS_ERROR_NONE; } -int location_manager_get_last_velocity(location_manager_h manager, int *climb, int *direction, int *speed, time_t * timestamp) +int location_manager_get_last_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t * timestamp) { LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(climb); @@ -601,14 +605,13 @@ int location_manager_get_last_accuracy(location_manager_h manager, location_accu return LOCATIONS_ERROR_NONE; } -int location_manager_set_position_updated_cb(location_manager_h manager, location_position_updated_cb callback, int interval, - void *user_data) +int location_manager_set_position_updated_cb(location_manager_h manager, location_position_updated_cb callback, int interval, void *user_data) { LOCATIONS_CHECK_CONDITION(interval >= 1 && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); LOCATIONS_NULL_ARG_CHECK(manager); location_manager_s *handle = (location_manager_s *) manager; - g_object_set(handle->object, "update-interval", interval, NULL); + g_object_set(handle->object, "pos-interval", interval, NULL); return __set_callback(_LOCATIONS_EVENT_TYPE_POSITION, manager, callback, user_data); } @@ -617,8 +620,13 @@ int location_manager_unset_position_updated_cb(location_manager_h manager) return __unset_callback(_LOCATIONS_EVENT_TYPE_POSITION, manager); } -int location_manager_set_velocity_updated_cb(location_manager_h manager, location_velocity_updated_cb callback, void *user_data) +int location_manager_set_velocity_updated_cb(location_manager_h manager, location_velocity_updated_cb callback, int interval, void *user_data) { + LOCATIONS_CHECK_CONDITION(interval >= 1 + && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; + g_object_set(handle->object, "vel-interval", interval, NULL); return __set_callback(_LOCATIONS_EVENT_TYPE_VELOCITY, manager, callback, user_data); } @@ -648,6 +656,30 @@ int location_manager_unset_zone_changed_cb(location_manager_h manager) return __unset_callback(_LOCATIONS_EVENT_TYPE_BOUNDARY, manager); } +int location_manager_get_distance(double start_latitude, double start_longitude, double end_latitude, double end_longitude, double *distance) +{ + LOCATIONS_NULL_ARG_CHECK(distance); + LOCATIONS_CHECK_CONDITION(start_latitude>=-90 && start_latitude<=90,LOCATION_BOUNDS_ERROR_INVALID_PARAMETER,"LOCATION_BOUNDS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(start_longitude>=-180 && start_longitude<=180,LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(end_latitude>=-90 && end_latitude<=90,LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(end_longitude>=-180 && end_longitude<=180,LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER"); + + int ret = LOCATION_ERROR_NONE; + ulong u_distance; + + LocationPosition *start = location_position_new (0, start_latitude, start_longitude, 0, LOCATION_STATUS_2D_FIX); + LocationPosition *end = location_position_new (0, end_latitude, end_longitude, 0, LOCATION_STATUS_2D_FIX); + + ret = location_get_distance (start, end, &u_distance); + if (ret != LOCATION_ERROR_NONE) { + return __convert_error_code(ret, (char *)__FUNCTION__); + } + + *distance = (double)u_distance; + + return LOCATIONS_ERROR_NONE; +} + int location_manager_send_command(const char *cmd) { LOCATIONS_NULL_ARG_CHECK(cmd); @@ -709,23 +741,15 @@ int gps_status_get_satellite(location_manager_h manager, int *num_of_active, int LOCATIONS_NULL_ARG_CHECK(num_of_inview); LOCATIONS_NULL_ARG_CHECK(timestamp); location_manager_s *handle = (location_manager_s *) manager; - if (handle->method == LOCATIONS_METHOD_HYBRID) { - LocationMethod _method = LOCATION_METHOD_NONE; - g_object_get(handle->object, "method", &_method, NULL); - if (_method != LOCATION_METHOD_GPS) { + LocationSatellite *sat = NULL; + int ret = location_get_satellite (handle->object, &sat); + if (ret != LOCATION_ERROR_NONE || sat == NULL) { + if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; } - } else if (handle->method != LOCATIONS_METHOD_GPS) { - LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; - } - LocationSatellite *sat = NULL; - g_object_get(handle->object, "satellite", &sat, NULL); - if (sat == NULL) { LOGE("[%s] LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", __FUNCTION__, LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; @@ -739,28 +763,36 @@ int gps_status_get_satellite(location_manager_h manager, int *num_of_active, int return LOCATIONS_ERROR_NONE; } +int gps_status_set_satellite_updated_cb(location_manager_h manager, gps_status_satellite_updated_cb callback, int interval, void *user_data) +{ + LOCATIONS_CHECK_CONDITION(interval >= 1 + && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; + g_object_set(handle->object, "sat-interval", interval, NULL); + return __set_callback(_LOCATIONS_EVENT_TYPE_SATELLITE, manager, callback, user_data); +} + +int gps_status_unset_satellite_updated_cb(location_manager_h manager) +{ + return __unset_callback(_LOCATIONS_EVENT_TYPE_SATELLITE, manager); +} + + int gps_status_foreach_satellites_in_view(location_manager_h manager, gps_status_get_satellites_cb callback, void *user_data) { LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(callback); location_manager_s *handle = (location_manager_s *) manager; - if (handle->method == LOCATIONS_METHOD_HYBRID) { - LocationMethod _method = LOCATION_METHOD_NONE; - g_object_get(handle->object, "method", &_method, NULL); - if (_method != LOCATION_METHOD_GPS) { + LocationSatellite *sat = NULL; + int ret = location_get_satellite (handle->object, &sat); + if (ret != LOCATION_ERROR_NONE || sat == NULL) { + if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; } - } else if (handle->method != LOCATIONS_METHOD_GPS) { - LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; - } - LocationSatellite *sat = NULL; - g_object_get(handle->object, "satellite", &sat, NULL); - if (sat == NULL) { LOGE("[%s] LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", __FUNCTION__, LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; @@ -789,25 +821,19 @@ int gps_status_get_last_satellite(location_manager_h manager, int *num_of_active LOCATIONS_NULL_ARG_CHECK(num_of_inview); LOCATIONS_NULL_ARG_CHECK(timestamp); location_manager_s *handle = (location_manager_s *) manager; - int ret; - if (handle->method == LOCATIONS_METHOD_HYBRID) { - LocationMethod _method = LOCATION_METHOD_NONE; - g_object_get(handle->object, "method", &_method, NULL); - if (_method != LOCATION_METHOD_GPS) { + int ret = LOCATION_ERROR_NONE; + LocationSatellite *last_sat = NULL; + ret = location_get_last_satellite(handle->object, &last_sat); + if (ret != LOCATION_ERROR_NONE || last_sat == NULL) { + if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; } - } else if (handle->method != LOCATIONS_METHOD_GPS) { - LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; - } - LocationSatellite *last_sat = NULL; - ret = location_get_last_satellite(handle->object, &last_sat); - if (ret != LOCATION_ERROR_NONE) { - return __convert_error_code(ret, (char *)__FUNCTION__); + LOGE("[%s] LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", __FUNCTION__, + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } *num_of_active = last_sat->num_of_sat_used; @@ -824,24 +850,18 @@ int gps_status_foreach_last_satellites_in_view(location_manager_h manager, gps_s LOCATIONS_NULL_ARG_CHECK(callback); location_manager_s *handle = (location_manager_s *) manager; int ret; - if (handle->method == LOCATIONS_METHOD_HYBRID) { - LocationMethod _method = LOCATION_METHOD_NONE; - g_object_get(handle->object, "method", &_method, NULL); - if (_method != LOCATION_METHOD_GPS) { + LocationSatellite *last_sat = NULL; + ret = location_get_last_satellite(handle->object, &last_sat); + if (ret != LOCATION_ERROR_NONE || last_sat == NULL) { + if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; } - } else if (handle->method != LOCATIONS_METHOD_GPS) { - LOGE("[%s] LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", __FUNCTION__, - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; - } - LocationSatellite *last_sat = NULL; - ret = location_get_last_satellite(handle->object, &last_sat); - if (ret != LOCATION_ERROR_NONE) { - return __convert_error_code(ret, (char *)__FUNCTION__); + LOGE("[%s] LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", __FUNCTION__, + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } int i; diff --git a/test/location_test.c b/test/location_test.c old mode 100755 new mode 100644 index 995338b..ea83a0a --- a/test/location_test.c +++ b/test/location_test.c @@ -232,10 +232,10 @@ void location_bounds_test() test_coords.latitude = 12; test_coords.longitude = 12; - if (location_bounds_is_contains_coordinates(bounds_poly, test_coords)) - printf("location_bounds_is_contains_coordinates() retrun TRUE \n"); + if (location_bounds_contains_coordinates(bounds_poly, test_coords)) + printf("location_bounds_contains_coordinates() retrun TRUE \n"); else - printf("location_bounds_is_contains_coordinates() retrun FALSE \n"); + printf("location_bounds_contains_coordinates() retrun FALSE \n"); //print current bounds ret = location_manager_foreach_boundary(manager, __location_bounds_cb, (void *)manager); @@ -249,7 +249,7 @@ void location_get_last_information_test() { int ret; double altitude, latitude, longitude; - int climb, direction, speed; + double climb, direction, speed; double horizontal, vertical; location_accuracy_level_e level; time_t timestamp; @@ -266,7 +266,7 @@ void location_get_last_information_test() if (ret != LOCATIONS_ERROR_NONE) { printf(" Fail : location_manager_get_last_velocity ---> %d \n", ret); } else { - printf("climb: %d, direction: %d, speed: %d\n", climb, direction, speed); + printf("climb: %f, direction: %f, speed: %f\n", climb, direction, speed); } ret = location_manager_get_last_accuracy(manager, &level, &horizontal, &vertical); -- 2.7.4