wpsapi.h

Go to the documentation of this file.

 
#ifndef _WPSAPI_H_
#define _WPSAPI_H_
 
#if defined WPSAPI_EXTENSION && !defined WPSAPI_STATIC
#  error WPSAPI_EXTENSION can be used only with WPSAPI_STATIC
#endif
 
#if defined WPSAPI_STATIC && !defined WPSAPI_EXTENSION
#  define WPSAPI_EXPORT
#else
#  if __GNUC__ >= 4
#    define WPSAPI_EXPORT __attribute__((visibility("default")))
#  elif defined _WIN32
#    ifdef WPSAPI_INTERNAL
#      define WPSAPI_EXPORT __declspec(dllexport)
#    else
#      define WPSAPI_EXPORT __declspec(dllimport)
#    endif
#  else
#    define WPSAPI_EXPORT
#  endif
#endif
 
#ifdef _WIN32
#  define WPSAPI_CALL __cdecl
#else
#  define WPSAPI_CALL
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum
{
    WPS_OK = 0,
 
    WPS_ERROR_SCANNER_NOT_FOUND = 1,
 
    WPS_ERROR_WIFI_NOT_AVAILABLE = 2,
 
    WPS_ERROR_NO_WIFI_IN_RANGE = 3,
 
    WPS_ERROR_UNAUTHORIZED = 4,
 
    WPS_ERROR_SERVER_UNAVAILABLE = 5,
 
    WPS_ERROR_LOCATION_CANNOT_BE_DETERMINED = 6,
 
    WPS_ERROR_PROXY_UNAUTHORIZED = 7,
 
    WPS_ERROR_FILE_IO = 8,
 
    WPS_ERROR_INVALID_FILE_FORMAT = 9,
 
    WPS_ERROR_TIMEOUT = 10,
 
    WPS_NOT_APPLICABLE = 11,
 
    WPS_GEOFENCE_ERROR = 12,
 
    WPS_ERROR_NOT_TUNED = 13,
 
    WPS_ERROR_NOT_SIGNED = 14,
 
    WPS_ERROR_LOCATION_SETTING_DISABLED = 15,
 
    WPS_ERROR_LOCATION_NOT_PERMITTED = 16,
 
    WPS_NOT_SUPPORTED = 17,
 
    WPS_ERROR_SERVICE_EXPIRED = 18,
 
    WPS_NOMEM = 98,
 
    WPS_ERROR = 99
} WPS_ReturnCode;
 
typedef enum
{
    WPS_STOP = 0,
    WPS_CONTINUE = 1
} WPS_Continuation;
 
typedef struct
{
    const char* username;
 
    const char* realm;
} WPS_SimpleAuthentication;
 
typedef enum
{
    WPS_NO_STREET_ADDRESS_LOOKUP,
 
    WPS_LIMITED_STREET_ADDRESS_LOOKUP,
 
    WPS_FULL_STREET_ADDRESS_LOOKUP
} WPS_StreetAddressLookup;
 
typedef struct
{
    char* name;
 
    char code[3];
} WPS_NameCode;
 
typedef struct
{
    char* street_number;
 
    char** address_line;
 
    char* city;
 
    char* postal_code;
 
    char* county;
 
    char* province;
 
    WPS_NameCode state;
 
    char* region;
 
    WPS_NameCode country;
 
    char* city_sub;
} WPS_StreetAddress;
 
typedef enum
{
    WPS_LOCATION_TYPE_2D,
    WPS_LOCATION_TYPE_3D
} WPS_LocationType;
 
typedef struct
{
 
    double latitude;
    double longitude;
 
    double hpe;
 
    double score;
 
    unsigned short nap;
 
    double speed;
 
    double bearing;
 
    WPS_StreetAddress* street_address;
 
    unsigned short ncell;
 
    unsigned short nlac;
 
    unsigned short nsat;
 
    unsigned short historicalLocationCount;
 
    unsigned char withIP;
 
    unsigned char hasScore;
 
    unsigned id;
 
    char* ip;
 
    unsigned char* hash;
 
    unsigned hashLength;
 
    unsigned char* signature;
 
    unsigned signatureLength;
 
    unsigned long timestamp;
 
    double altitude;
 
    WPS_LocationType type;
 
    unsigned long age;
} WPS_Location;
 
typedef struct
{
    char* ip;
 
 
    double latitude;
    double longitude;
 
    WPS_StreetAddress* street_address;
} WPS_IPLocation;
 
WPSAPI_EXPORT const char* WPSAPI_CALL
WPS_version();
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_load();
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_unload();
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_location(const WPS_SimpleAuthentication* authentication,
             WPS_StreetAddressLookup street_address_lookup,
             WPS_Location** location);
 
typedef WPS_Continuation
    (WPSAPI_CALL *WPS_LocationCallback)(void* arg,
                                        WPS_ReturnCode code,
                                        const WPS_Location* location,
                                        const void* reserved);
 
typedef WPS_Continuation
(WPSAPI_CALL *WPS_CertifiedLocationCallback)(void* arg,
                                             WPS_ReturnCode code,
                                             const WPS_Location** locations,
                                             unsigned nlocations,
                                             const void* reserved);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_periodic_location(const WPS_SimpleAuthentication* authentication,
                      WPS_StreetAddressLookup street_address_lookup,
                      unsigned long period,
                      unsigned iterations,
                      WPS_LocationCallback callback,
                      void* arg);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_certified_location(const WPS_SimpleAuthentication* authentication,
                       WPS_StreetAddressLookup street_address_lookup,
                       WPS_CertifiedLocationCallback callback,
                       void* arg);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_signed_certified_location(const WPS_SimpleAuthentication* authentication,
                              WPS_StreetAddressLookup street_address_lookup,
                              const unsigned char* salt,
                              unsigned saltLen,
                              WPS_CertifiedLocationCallback callback,
                              void* arg);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_ip_location(const WPS_SimpleAuthentication* authentication,
                WPS_StreetAddressLookup street_address_lookup,
                WPS_IPLocation** location);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_offline_token(const WPS_SimpleAuthentication* authentication,
                  const unsigned char* key,
                  unsigned key_length,
                  unsigned char** token,
                  unsigned* token_size);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_offline_location(const WPS_SimpleAuthentication* authentication,
                     const unsigned char* key,
                     unsigned key_length,
                     const unsigned char* token,
                     unsigned token_size,
                     WPS_Location** location);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_free_offline_token(unsigned char* token);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_free_location(WPS_Location*);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_free_ip_location(WPS_IPLocation*);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_set_proxy(const char* address,
              int port,
              const char* user,
              const char* password);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_set_server_url(const char* url);
 
WPSAPI_EXPORT void WPSAPI_CALL
WPS_set_user_agent(const char* ua);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_local_files_path(const char** paths);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_tier2_area(const char* dirpath, unsigned size);
 
typedef WPS_Continuation
    (WPSAPI_CALL *WPS_TilingCallback)(void* arg,
                                      unsigned tileNumber,
                                      unsigned tileTotal);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_tiling(const WPS_SimpleAuthentication* authentication,
               const char* dirpath,
               unsigned maxDataSizePerSession,
               unsigned maxDataSizeTotal,
               WPS_TilingCallback callback,
               void* arg);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_tiling(const char* dirpath,
           unsigned maxDataSizePerSession,
           unsigned maxDataSizeTotal,
           WPS_TilingCallback callback,
           void* arg);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_key(const char* key);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_auth(const char* key, const char* sku);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_auth_token(const char* token);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_registration_user(const WPS_SimpleAuthentication* authentication);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_register_user(const WPS_SimpleAuthentication* authentication,
                  const WPS_SimpleAuthentication* new_authentication);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_tune_location(const WPS_SimpleAuthentication* authentication,
                  const WPS_Location* location);
 
typedef enum
{
    WPS_GEOFENCE_ENTER,
 
    WPS_GEOFENCE_LEAVE,
 
    WPS_GEOFENCE_INSIDE,
 
    WPS_GEOFENCE_OUTSIDE
} WPS_GeoFenceType;
 
typedef struct
{
    unsigned size;
 
 
    double latitude;
    double longitude;
 
    unsigned radius;
 
    WPS_GeoFenceType type;
 
    unsigned long period;
} WPS_GeoFence;
 
typedef void* WPS_GeoFenceHandle;
 
typedef WPS_Continuation
    (WPSAPI_CALL *WPS_GeoFenceCallback)(void* arg,
                                        const WPS_GeoFence* geofence,
                                        const WPS_Location* location,
                                        const void* reserved);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_geofence_set(const WPS_GeoFence* geofence,
                 WPS_GeoFenceCallback callback,
                 void* arg,
                 WPS_GeoFenceHandle* handle);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_geofence_cancel(WPS_GeoFenceHandle handle);
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_geofence_cancel_all();
 
WPSAPI_EXPORT WPS_ReturnCode WPSAPI_CALL
WPS_set_tunable(const char* key, const char* value);
 
#ifdef __cplusplus
}
#endif
 
#endif // _WPSAPI_H_