msm8998: Update to 07.00.00.279.027
.: from hardware/qcom/gps
fb6ada7 LOC logging macro changes
a41371d Adding ATL call flow to new Loc API interface
1f0f30d hidl gnss hal 1.0 implementation
dcaa2b1 LocationAPI implementation
17227a4 Add explicit liblog dependency
10f961e fixing a race condition on MsgTask::destroy() am: 4eda8e1eab am: 4797bfa900 am: acd98bcaab
dabb110 fixing a race condition on MsgTask::destroy() am: 4eda8e1eab am: 6a27094a7b am: ecb76928eb
acd98bc fixing a race condition on MsgTask::destroy() am: 4eda8e1eab am: 4797bfa900
ecb7692 fixing a race condition on MsgTask::destroy() am: 4eda8e1eab am: 6a27094a7b
4797bfa fixing a race condition on MsgTask::destroy() am: 4eda8e1eab
6a27094 fixing a race condition on MsgTask::destroy() am: 4eda8e1eab
4eda8e1 fixing a race condition on MsgTask::destroy()
96349ca msm8998: Update to 07.00.00.253.056
f7bbba4 Merge "Depend on libandroid_runtime" am: 82dd9367cf am: 1a94090191 am: 634a10c780 am: 2a7e5e066f
2a7e5e0 Merge "Depend on libandroid_runtime" am: 82dd9367cf am: 1a94090191 am: 634a10c780
634a10c Merge "Depend on libandroid_runtime" am: 82dd9367cf am: 1a94090191
1a94090 Merge "Depend on libandroid_runtime" am: 82dd9367cf
82dd936 Merge "Depend on libandroid_runtime"
edc762c Depend on libandroid_runtime
ada6527 Depend on libandroid_runtime
435b813 msm8998: rename msmcobalt to msm8998 am: 02f13da8e1 am: 6e9861804c
6e98618 msm8998: rename msmcobalt to msm8998 am: 02f13da8e1
02f13da msm8998: rename msmcobalt to msm8998
99a2828 Merge "Added XTRA CA path to gps.conf am: 47b626358a am: da0886d286" into nyc-mr2-dev-plus-aosp am: bd59daa7b2
0be00e4 Added XTRA CA path to gps.conf am: 47b626358a am: da0886d286 am: 558ea5a345
3626f27 Added XTRA CA path to gps.conf am: 47b626358a am: 07377b1319 am: cc1c500b57
bd59daa Merge "Added XTRA CA path to gps.conf am: 47b626358a am: da0886d286" into nyc-mr2-dev-plus-aosp
558ea5a Added XTRA CA path to gps.conf am: 47b626358a am: da0886d286
cc1c500 Added XTRA CA path to gps.conf am: 47b626358a am: 07377b1319
07377b1 Added XTRA CA path to gps.conf am: 47b626358a
da0886d Added XTRA CA path to gps.conf am: 47b626358a
47b6263 Added XTRA CA path to gps.conf
73da450 msmcobalt: Update to LA.UM.5.7_RB1.07.00.00.251.006 am: c2fbb41f69 am: 2fc9d83718
2fc9d83 msmcobalt: Update to LA.UM.5.7_RB1.07.00.00.251.006 am: c2fbb41f69
c2fbb41 msmcobalt: Update to LA.UM.5.7_RB1.07.00.00.251.006
088623b gps: enable SAP am: c5b4bd3794 am: e646f881b5
e646f88 gps: enable SAP am: c5b4bd3794
c5b4bd3 gps: enable SAP
b0f6b2c msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14 am: f1c1d98026 am: 9e55f15c05
faf90fa fixed a copy paste error am: 90ff845856 am: 16f3d1e963 am: b0d47c984c
9e55f15 msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14 am: f1c1d98026
b0d47c9 fixed a copy paste error am: 90ff845856 am: 16f3d1e963
f1c1d98 msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14
16f3d1e fixed a copy paste error am: 90ff845856
5446d0f Prevent gps.conf from being included twice on swordfish.
0bedfd7 Changes to have swordfish build.
c992f49 msmcobalt: Update to 07.00.00.253.042 am: 63f8eb733a am: a88d1331b7
a88d133 msmcobalt: Update to 07.00.00.253.042 am: 63f8eb733a
63f8eb7 msmcobalt: Update to 07.00.00.253.042
2e35081 Merge "fix warning: Use of memory after it is freed" am: 05ef6c51f6 am: 314acc48fb am: 75034fd5a1 am: c5484e5147
c5484e5 Merge "fix warning: Use of memory after it is freed" am: 05ef6c51f6 am: 314acc48fb am: 75034fd5a1
75034fd Merge "fix warning: Use of memory after it is freed" am: 05ef6c51f6 am: 314acc48fb
314acc4 Merge "fix warning: Use of memory after it is freed" am: 05ef6c51f6
05ef6c5 Merge "fix warning: Use of memory after it is freed"
9853496 fix warning: Use of memory after it is freed
cf7e221 msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14 am: 829ed002cb am: 21c8fa6dc8
21c8fa6 msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14 am: 829ed002cb
829ed00 msmcobalt: Update to 07.00.00.253.039 am: bc2807add2 am: 93f2dceb14
93f2dce msmcobalt: Update to 07.00.00.253.039 am: bc2807add2
bc2807a msmcobalt: Update to 07.00.00.253.039
539077a fixed a copy paste error am: 90ff845856 am: 30f9d208cb am: 39fe507fdb
39fe507 fixed a copy paste error am: 90ff845856 am: 30f9d208cb
30f9d20 fixed a copy paste error am: 90ff845856
90ff845 fixed a copy paste error
1566b37 msmcobalt: update to 07.00.00.253.035 am: 1c56f4feb3 am: dfc9c9ed55 am: c31584c53c
c31584c msmcobalt: update to 07.00.00.253.035 am: 1c56f4feb3 am: dfc9c9ed55
dfc9c9e msmcobalt: update to 07.00.00.253.035 am: 1c56f4feb3
1c56f4f msmcobalt: update to 07.00.00.253.035
06ef7a3 msmcobalt: Update to 07.00.00.253.032 am: 5bea9589b6 am: 2f928597e7 am: 0ebc797f0b
518ba35 msmcobalt: Update to 07.00.00.253.024 am: 6f2a63d31d am: 5c07def4f2 am: 0061f41bb8
0ebc797 msmcobalt: Update to 07.00.00.253.032 am: 5bea9589b6 am: 2f928597e7
0061f41 msmcobalt: Update to 07.00.00.253.024 am: 6f2a63d31d am: 5c07def4f2
2f92859 msmcobalt: Update to 07.00.00.253.032 am: 5bea9589b6
5c07def msmcobalt: Update to 07.00.00.253.024 am: 6f2a63d31d
5bea958 msmcobalt: Update to 07.00.00.253.032
6f2a63d msmcobalt: Update to 07.00.00.253.024
018788d deprecate legacy NTP time download am: 685517e30a am: 2191154ca6
2191154 deprecate legacy NTP time download am: 685517e30a
685517e deprecate legacy NTP time download
2f5fecd Add missing liblog dependency
8f129a6 Add missing liblog dependency am: 3241b11d40
3241b11 Add missing liblog dependency
6a7bcbc Merge "Add missing liblog dependency" am: ac7c3e2801 am: 319408f97b am: 7eaa57e398 am: a09f183289
a09f183 Merge "Add missing liblog dependency" am: ac7c3e2801 am: 319408f97b am: 7eaa57e398
7eaa57e Merge "Add missing liblog dependency" am: ac7c3e2801 am: 319408f97b
319408f Merge "Add missing liblog dependency" am: ac7c3e2801
ac7c3e2 Merge "Add missing liblog dependency"
b452837 Add missing liblog dependency
1fa137f Merge "Add missing liblog dependency"
6c3c4bb multiple XTRA downloaders could be triggered on boot up am: 351d6980ab am: 9cb11ad806
9bc19df XTRA Client 2.0 am: d304a98437 am: 769e19e20b
9cb11ad multiple XTRA downloaders could be triggered on boot up am: 351d6980ab
769e19e XTRA Client 2.0 am: d304a98437
351d698 multiple XTRA downloaders could be triggered on boot up
d304a98 XTRA Client 2.0
532f337 Add missing liblog dependency
bd2b55a Merge "Add missing liblog dependency" am: 0cb64f83b7 am: d750da0bb5 am: 37639b35f8 am: 34ecd7320a
34ecd73 Merge "Add missing liblog dependency" am: 0cb64f83b7 am: d750da0bb5 am: 37639b35f8
37639b3 Merge "Add missing liblog dependency" am: 0cb64f83b7 am: d750da0bb5
d750da0 Merge "Add missing liblog dependency" am: 0cb64f83b7
0cb64f8 Merge "Add missing liblog dependency"
c784d5e Add missing liblog dependency
9c86882 fix Converting NULL to non-pointer type warning
2d6a48f msmcobalt: fix wrong absolute path am: cb4d2fd2f8 am: 95bae3332a am: 9d5dee88dc
9d5dee8 msmcobalt: fix wrong absolute path am: cb4d2fd2f8 am: 95bae3332a
f94f1f8 Merge changes I1561518c,Ic7ad172a into cw-f-dev am: 146bb3bc6e am: 54c926623a
d258a81 Adding TARGET_NO_GNSS check while creating LocApi am: d4fd1e91f6 am: 24fdf8a95c
95d59eb Fix gps compilation for 8x26 am: f89bb9b1af am: 004a0335cf
95bae33 msmcobalt: fix wrong absolute path am: cb4d2fd2f8
54c9266 Merge changes I1561518c,Ic7ad172a into cw-f-dev am: 146bb3bc6e
24fdf8a Adding TARGET_NO_GNSS check while creating LocApi am: d4fd1e91f6
004a033 Fix gps compilation for 8x26 am: f89bb9b1af
146bb3b Merge changes I1561518c,Ic7ad172a into cw-f-dev
cb4d2fd msmcobalt: fix wrong absolute path
d4fd1e9 Adding TARGET_NO_GNSS check while creating LocApi
f89bb9b Fix gps compilation for 8x26
e9d0c8b msmcobalt: import from LA.UM.5.7.R1.06.00.01.253.019 am: 129edaf7d0 am: ef384b99bc am: 9ea942d749
9ea942d msmcobalt: import from LA.UM.5.7.R1.06.00.01.253.019 am: 129edaf7d0 am: ef384b99bc
ef384b9 msmcobalt: import from LA.UM.5.7.R1.06.00.01.253.019 am: 129edaf7d0
129edaf msmcobalt: import from LA.UM.5.7.R1.06.00.01.253.019
47d02ce DO NOT MERGE ANYWHERE: (nyc-dr1-dev) Move local gps/sap configuration to Context am: 950f058081 -s ours am: bece38a9ef -s ours am: 7a2809aec4 -s ours am: 4ceccaca1d -s ours
4ceccac DO NOT MERGE ANYWHERE: (nyc-dr1-dev) Move local gps/sap configuration to Context am: 950f058081 -s ours am: bece38a9ef -s ours am: 7a2809aec4 -s ours
7a2809a DO NOT MERGE ANYWHERE: (nyc-dr1-dev) Move local gps/sap configuration to Context am: 950f058081 -s ours am: bece38a9ef -s ours
bece38a DO NOT MERGE ANYWHERE: (nyc-dr1-dev) Move local gps/sap configuration to Context am: 950f058081 -s ours
950f058 DO NOT MERGE ANYWHERE: (nyc-dr1-dev) Move local gps/sap configuration to Context
4ac084d Move local gps/sap configuration to Context am: 8cf3e0e4dd am: 10144bef7a am: ecb4275f4f
ecb4275 Move local gps/sap configuration to Context am: 8cf3e0e4dd am: 10144bef7a
10144be Move local gps/sap configuration to Context am: 8cf3e0e4dd
8cf3e0e Move local gps/sap configuration to Context
b3a031e Support GnssMeasurement am: 64efbd901d am: 2bffa26206
2bffa26 Support GnssMeasurement am: 64efbd901d
64efbd9 Support GnssMeasurement
48f3b8f Fix logging level and remove nmea log am: fecc8ce536 am: 155a71c33b
b963bde multiple XTRA downloaders could be triggered on boot up am: e0bc79ad55 am: fb1c904613
1b4677e Return the correct length of nmea sentence. am: 76733cd8ab am: 0af33eddac
3c4612e XTRA Client 2.0 am: 16ac9aa2c1 am: b20fb31405
155a71c Fix logging level and remove nmea log am: fecc8ce536
fb1c904 multiple XTRA downloaders could be triggered on boot up am: e0bc79ad55
0af33ed Return the correct length of nmea sentence. am: 76733cd8ab
b20fb31 XTRA Client 2.0 am: 16ac9aa2c1
fecc8ce Fix logging level and remove nmea log
e0bc79a multiple XTRA downloaders could be triggered on boot up
76733cd Return the correct length of nmea sentence.
16ac9aa XTRA Client 2.0
15e9cf7 Resolved CLANG reported errors. am: 9e34f5b67a am: cdc5bbcfc8
cdc5bbc Resolved CLANG reported errors. am: 9e34f5b67a
9e34f5b Resolved CLANG reported errors.
6bf3f62 Don\\'t include default gps.conf if device-specific overlay exists am: 83280d12ce am: c4343c4375
c4343c4 Don\'t include default gps.conf if device-specific overlay exists am: 83280d12ce
83280d1 Don't include default gps.conf if device-specific overlay exists
2ad9cb9 Merge "Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560 am: 2129a41fce" into nyc-mr1-dev-plus-aosp am: c35b347362
c6b14d2 Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560 am: 107456fbba am: d731d2f3ca
c35b347 Merge "Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560 am: 2129a41fce" into nyc-mr1-dev-plus-aosp
475bd7a Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560 am: 2129a41fce
d731d2f Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560 am: 107456fbba
107456f Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560
2129a41 Merge "Default apn ip type to ipv4" into nyc-dev am: e98a418560
e98a418 Merge "Default apn ip type to ipv4" into nyc-dev
d7b1204 Default apn ip type to ipv4
86a36d3 Remove problematic dependency am: de7700cdd7 am: f7cb5caf08
5729eb7 makefile change to enable CLANG am: 7fd74c908e am: 6b6a10c860
f7cb5ca Remove problematic dependency am: de7700cdd7
6b6a10c makefile change to enable CLANG am: 7fd74c908e
de7700c Remove problematic dependency
7fd74c9 makefile change to enable CLANG
1c21715 Merge "msm8974: remove from top level makefile am: 53bf15aab7 am: c5e73a33f3" into nyc-mr1-dev-plus-aosp am: f1ea4b1864
9486084 msm8974: remove from top level makefile am: 53bf15aab7 am: 5e4de8a60e am: 2fdf772c2d
f1ea4b1 Merge "msm8974: remove from top level makefile am: 53bf15aab7 am: c5e73a33f3" into nyc-mr1-dev-plus-aosp
1686b6b msm8974: remove from top level makefile am: 53bf15aab7 am: c5e73a33f3
2fdf772 msm8974: remove from top level makefile am: 53bf15aab7 am: 5e4de8a60e
c5e73a3 msm8974: remove from top level makefile am: 53bf15aab7
5e4de8a msm8974: remove from top level makefile am: 53bf15aab7
53bf15a msm8974: remove from top level makefile
c3d974a msm8974: deprecate msm8974 am: 486ab75159 am: 7f3057afa8 am: a489465053
a7663b4 resolve merge conflicts of 486ab75 to nyc-dev-plus-aosp am: dbb62f01af am: f18370c8a6
a489465 msm8974: deprecate msm8974 am: 486ab75159 am: 7f3057afa8
f18370c resolve merge conflicts of 486ab75 to nyc-dev-plus-aosp am: dbb62f01af
dbb62f0 resolve merge conflicts of 486ab75 to nyc-dev-plus-aosp
7f3057a msm8974: deprecate msm8974 am: 486ab75159
486ab75 msm8974: deprecate msm8974
0a581f9 Support GnssMeasurement am: 78bdcaf6f9 am: a56327631f
a563276 Support GnssMeasurement am: 78bdcaf6f9
78bdcaf Support GnssMeasurement
35d8351 Disable GPS only for adp8064 and fox
04783a7 gps: fix msm8994 typo am: 728d6c7523 am: f3f2274403 am: db4a9d6d6c
df040e1 gps: fix msm8994 typo am: 728d6c7523 am: 1df22d3173 am: 5a003101ce
db4a9d6 gps: fix msm8994 typo am: 728d6c7523 am: f3f2274403
5a00310 gps: fix msm8994 typo am: 728d6c7523 am: 1df22d3173
1df22d3 gps: fix msm8994 typo am: 728d6c7523
f3f2274 gps: fix msm8994 typo am: 728d6c7523
728d6c7 gps: fix msm8994 typo
0226df7 Fix memory leak in loc_update_conf(). am: a31fdb9 am: e848997
e848997 Fix memory leak in loc_update_conf(). am: a31fdb9
a31fdb9 Fix memory leak in loc_update_conf().
3bed97f Modify makefile to point to new GPS HAL path am: f6d4513 am: e6b49f2 am: 8a06ba7 am: ae527de
ae527de Modify makefile to point to new GPS HAL path am: f6d4513 am: e6b49f2 am: 8a06ba7
8a06ba7 Modify makefile to point to new GPS HAL path am: f6d4513 am: e6b49f2
e6b49f2 Modify makefile to point to new GPS HAL path am: f6d4513
f6d4513 Modify makefile to point to new GPS HAL path
df55d81 Add the support for geofence dwell am: 293643d am: 970ce96 am: 1d40ddf
1d40ddf Add the support for geofence dwell am: 293643d am: 970ce96
970ce96 Add the support for geofence dwell am: 293643d
293643d Add the support for geofence dwell
b5a649c make LocSharedLock::mRef ops atomic am: 37d684c am: a2a181b am: 6639c61
ee92bb7 Add support for dynamic TBF updating am: 0fde446 am: 85f8ea7 am: eba9942
3df5842 encode field separator characters am: d0d586a am: 06e3b77 am: c6c6ed5
de6cdff Xtra client always reports carrier as \'unknown\' am: 25c1936 am: c421d38 am: 360951d
6639c61 make LocSharedLock::mRef ops atomic am: 37d684c am: a2a181b
eba9942 Add support for dynamic TBF updating am: 0fde446 am: 85f8ea7
c6c6ed5 encode field separator characters am: d0d586a am: 06e3b77
360951d Xtra client always reports carrier as \'unknown\' am: 25c1936 am: c421d38
a2a181b make LocSharedLock::mRef ops atomic am: 37d684c
85f8ea7 Add support for dynamic TBF updating am: 0fde446
06e3b77 encode field separator characters am: d0d586a
c421d38 Xtra client always reports carrier as \'unknown\' am: 25c1936
2ed9a9d Add the support for geofence dwell am: b12c98c20a am: 621d69f7eb
621d69f Add the support for geofence dwell am: b12c98c20a
b12c98c Add the support for geofence dwell
37d684c make LocSharedLock::mRef ops atomic
0fde446 Add support for dynamic TBF updating
d0d586a encode field separator characters
25c1936 Xtra client always reports carrier as 'unknown'
82a0698 Rename QcomGnssSvStatus to QtiGnssSvStatus am: 2e0c5f2f0d am: 0ededfbfac
ef75e07 Create msm8994 target for GPS HAL am: 8c2d3d5afc am: 76b3527c06
0ededfb Rename QcomGnssSvStatus to QtiGnssSvStatus am: 2e0c5f2f0d
76b3527 Create msm8994 target for GPS HAL am: 8c2d3d5afc
2e0c5f2 Rename QcomGnssSvStatus to QtiGnssSvStatus
8c2d3d5 Create msm8994 target for GPS HAL
1b898fc Merge "Suppress unused-parameter warnings in hardware/qcom/gps/" into nyc-dev am: 20160f64d5 am: 274f4455bc
274f445 Merge "Suppress unused-parameter warnings in hardware/qcom/gps/" into nyc-dev am: 20160f64d5
20160f6 Merge "Suppress unused-parameter warnings in hardware/qcom/gps/" into nyc-dev
ddb6532 Merge "Fix duplicate gps.conf for Flo/Deb" am: d5810f1a3a am: 0999be14ee am: b585f64c87
b585f64 Merge "Fix duplicate gps.conf for Flo/Deb" am: d5810f1a3a am: 0999be14ee
0999be1 Merge "Fix duplicate gps.conf for Flo/Deb" am: d5810f1a3a
d5810f1 Merge "Fix duplicate gps.conf for Flo/Deb"
4b35907 Fix duplicate gps.conf for Flo/Deb
155639f Merge "Fix duplicate gps.conf for Shamu/Hammerhead" am: a3d4e93d67 am: 6fccfd8f5f am: 34350a3a3b
34350a3 Merge "Fix duplicate gps.conf for Shamu/Hammerhead" am: a3d4e93d67 am: 6fccfd8f5f
6fccfd8 Merge "Fix duplicate gps.conf for Shamu/Hammerhead" am: a3d4e93d67
a3d4e93 Merge "Fix duplicate gps.conf for Shamu/Hammerhead"
8c406e3 resolve merge conflicts of 12a7f538f6 to nyc-dev am: 38487b179c am: 6a27c23732
6a27c23 resolve merge conflicts of 12a7f538f6 to nyc-dev am: 38487b179c
38487b1 resolve merge conflicts of 12a7f538f6 to nyc-dev
12a7f53 msm8909: Fix compilation issues with HAL GPS
38785f2 Suppress unused-parameter warnings in hardware/qcom/gps/
6cf5d45 Fix duplicate gps.conf for Shamu/Hammerhead
1571b12 Merge "gps: Avoid duplicate gps.conf" am: 437931edd2 am: 03937b8a1b am: 244e0ac48d
244e0ac Merge "gps: Avoid duplicate gps.conf" am: 437931edd2 am: 03937b8a1b
03937b8 Merge "gps: Avoid duplicate gps.conf" am: 437931edd2
437931e Merge "gps: Avoid duplicate gps.conf"
558f1da gps: Avoid duplicate gps.conf
f0b6bd8 Merge commit \'e7c98642e1e156ea6cde1238cd0006f669cfb696\' into HEAD am: 2819314769 am: a1df2abd8e
a1df2ab Merge commit \'e7c98642e1e156ea6cde1238cd0006f669cfb696\' into HEAD am: 2819314769
2819314 Merge commit 'e7c98642e1e156ea6cde1238cd0006f669cfb696' into HEAD
d63e720 Merge "Add missing liblog dependency" am: c5a4eb13dc am: 73d77abd43
73d77ab Merge "Add missing liblog dependency" am: c5a4eb13dc
c5a4eb1 Merge "Add missing liblog dependency"
53f040d Add missing liblog dependency
70db819 Merge "Fixed the build break" into nyc-dev am: 976ed0484f
976ed04 Merge "Fixed the build break" into nyc-dev
2ec254f Fixed the build break
c9a6ef1 gps: Avoid duplicate gps.conf am: 420b042f38
420b042 gps: Avoid duplicate gps.conf
96d10a1 [DO NOT MERGE] gps: Update to proprietary drop AU_LINUX_ANDROID_LA.HB.1.3.9.06.00.01.213.002 am: f53ac3ae2f -s ours
f53ac3a [DO NOT MERGE] gps: Update to proprietary drop AU_LINUX_ANDROID_LA.HB.1.3.9.06.00.01.213.002
3511668 Merge "gps: Update to proprietary drop AU_LINUX_ANDROID_LA.HB.1.3.9.06.00.01.213.002"
4fb2620 gps: Update to proprietary drop AU_LINUX_ANDROID_LA.HB.1.3.9.06.00.01.213.002
123cac6 gps: Avoid duplicate gps.conf
f764372 msm8996: add GPS HAL to top level makefile
ff62c84 msm8996: add top level makefile to msm8996 GPS HAL directory
86009d7 msm8996: fix makefile to point to chip specific directory
4035be2 msm8996: Add initial GPS HAL drop
cffbb9e resolve merge conflicts of e7c98642e1 to master.
e7c9864 gps: msm8909w caf release LW.BR.1.0-00410-8x09w.0
02685cb Workaround for adp8064
7d84e9e Merge "Fix ASan global-buffer-overflow in loc_set_config_entry."
eca401b am 0c7fdf01: qcom/gps: update gps hal
0c7fdf0 qcom/gps: update gps hal
9198ff2 Properly convert GpsXtraCallbacks to GpsXtraExtCallbacks.
aa6e5af Fix ASan global-buffer-overflow in loc_set_config_entry.
98cb761 msm8960: Fix build errors
5c7552e Do not build GPS HAL for msm8916
45b9829 Fix some compilation issues with legacy targets
bfff634 gps: upgrade GPS HAL to latest
51025d5 Do not build GPS HAL for msm8916
0e4f469 am 5191b0fe: am 2f930f38: Merge "Fix "error: \'strerror\' was not declared in this scope"."
5191b0f am 2f930f38: Merge "Fix "error: \'strerror\' was not declared in this scope"."
2f930f3 Merge "Fix "error: 'strerror' was not declared in this scope"."
9e09232 Fix "error: 'strerror' was not declared in this scope".
42e8b5d am c534e7f3: am 05e3dc51: Merge "Add missing includes."
c534e7f am 05e3dc51: Merge "Add missing includes."
05e3dc5 Merge "Add missing includes."
7757808 Add missing includes.
68dd2c8 am c3e0eb7c: am 1ba57de8: Merge "Add missing <string.h> include."
c3e0eb7 am 1ba57de8: Merge "Add missing <string.h> include."
1ba57de Merge "Add missing <string.h> include."
ccfd464 Add missing <string.h> include.
0b31322 am 5d1b68b5: am 66b3250c: carrier configured GPS_LOCK value missed out
5d1b68b am 66b3250c: carrier configured GPS_LOCK value missed out
66b3250 carrier configured GPS_LOCK value missed out
9c557a8 am bdaef3e5: am 3ce5de3a: Merge "Cleanup Obsolete LOCAL_PRELINK_MODULE."
bdaef3e am 3ce5de3a: Merge "Cleanup Obsolete LOCAL_PRELINK_MODULE."
3ce5de3 Merge "Cleanup Obsolete LOCAL_PRELINK_MODULE."
38bc21f Cleanup Obsolete LOCAL_PRELINK_MODULE.
a0de11c am 67a679de: am e5949fd1: Merge "C++11 compatibility fixes."
67a679d am e5949fd1: Merge "C++11 compatibility fixes."
e5949fd Merge "C++11 compatibility fixes."
6076fa7 am 0afd2944: am f01db6fc: Merge "Add missing include."
0afd294 am f01db6fc: Merge "Add missing include."
f01db6f Merge "Add missing include."
35ad85c C++11 compatibility fixes.
93cad3f Add missing include.
53c2cf1 Add missing include.
534f4aa am 4750276b: Merge "Add a missing include."
4750276 Merge "Add a missing include."
3074723 Add a missing include.
8aac9d3 Revert "Revert "GNSS measurement""
a8f9a02 Revert "GNSS measurement"
af0c0cc GNSS measurement
2344717 support reinjecting supl url for sim hot swap
b2c66a0 GPS lock is stuck as disabled after post powerup enablement
1300ae6 GPS LOCK did not work when NMEA_PROVIDER follows it
8aa503a GPS_LOCK configuration support
dd587e5 allow reconfiguration update happen before HAL init
fe66007 adding update config post power up
9aba726 correct AGpsStatus size in call to reportAgpsStatus
74b1898 GPS HAL: actually remove build dependency on libmdmdetect
2c4f9ae GPS HAL: decouple 8x84 targets from vendor/
0d00b9e Add support for IPV6 in AGPS Interface
1d49400 Agps Cert Install Api Implementation
33627a4 Fix regression issues with msm8960 hal split
baa459d flounder: remove filter out check of TARGET_ARCH for arm64
87543bf Add conditional compilation for libmdmdetect
8369d5b Revert "Remove masks for Glonass"
5cf20a0 Changes for GPS HAL compilation
47ad5e4 Merge branch 'KK.04.04.02.010.399' into l-pdk
ec6e5d3 Split GPS HAL for older targets
fd8c2c3 Fix build.
07c3401 Revert "Revert "Remove masks for Glonass""
0ed9ab1 Revert "Merge branch 'KK.04.04.02.010.399' into l-pdk"
544e9a1 Merge "Revert "Add conditional compilation for libmdmdetect""
408e216 Revert "Add conditional compilation for libmdmdetect"
d500f4f Add conditional compilation for libmdmdetect
8a20422 Revert "Remove masks for Glonass"
6270087 Changes for GPS HAL compilation
8c61f8c Merge branch 'KK.04.04.02.010.399' into l-pdk
4fe12bb Split GPS HAL for older targets
f2d8258 Merge "Revert "Split GPS HAL for older targets""
2a0deb9 Revert "Split GPS HAL for older targets"
a4a8ee2 Merge "Revert "Changes for GPS HAL compilation""
915c96c Revert "Changes for GPS HAL compilation"
c02d4b1 Add IPv6 support to GPS HAL.
5527c15 Add option to fallback to LocApiV02
07bee4d am a41314bd: Resolved On-Demand XTRA time injection issue
a41314b Resolved On-Demand XTRA time injection issue
1fdba83 Resolved On-Demand XTRA time injection issue
8f6bca4 Revert "Fix inject NTP time fail"
0acd743 Fix LocSvc log spam issue
04bfb8f Fix inject NTP time fail
4c50617 Bug fixed in AGPS checks
9ca398a Include this Android.mk only if BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE is defined
e14a6c8 Merge latest gps hal
baa4c49 am 2a9f38e7: Merge "gps: geofence hal integration" into jb-mr2-dev
af615e3 am ce5efcc5: Add liblog
5899c82 am c65fed03: gps: Runtime detection between apq v/s mdm gps support
fa96e0d am ade0338d: moved most of the GPS HAL back to aosp
c7e36f3 am 52f4c8ca: add LOCAL_MODULE_OWNER := qcom to gps modules
2610479 am 34ee0955: Revert "remove loc_api from hardware/qcom/gps"
8229399 am 63e3dc43: (-s ours) am 3dac3016: am 65102c39: am 47210994: (-s ours) am c2f34af0: (-s ours) Reconcile with jb-mr1-release - do not merge
Change-Id: I9016a28c2c84fe39d3d3e7fe4183c3ce6df99d51
Signed-off-by: Thierry Strudel <tstrudel@google.com>
(cherry picked from commit b4dcb0e3da7f3f737289d237b53b6b5e904b5284)
diff --git a/msm8998/android/AGnss.cpp b/msm8998/android/AGnss.cpp
new file mode 100644
index 0000000..c497ed4
--- /dev/null
+++ b/msm8998/android/AGnss.cpp
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_AGnssInterface"
+
+#include <log_util.h>
+#include "Gnss.h"
+#include "AGnss.h"
+#include <gps_extended_c.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+sp<IAGnssCallback> AGnss::sAGnssCbIface = nullptr;
+
+AGnss::AGnss(Gnss* gnss) : mGnss(gnss) {
+}
+
+void AGnss::agnssStatusIpV4Cb(IAGnssCallback::AGnssStatusIpV4 status){
+
+ sAGnssCbIface->agnssStatusIpV4Cb(status);
+}
+
+Return<void> AGnss::setCallback(const sp<IAGnssCallback>& callback) {
+
+ if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
+ LOC_LOGE("Null GNSS interface");
+ return Void();
+ }
+
+ // Save the interface
+ sAGnssCbIface = callback;
+
+ mGnss->getGnssInterface()->agpsInit((void*)agnssStatusIpV4Cb);
+ return Void();
+}
+
+Return<bool> AGnss::dataConnClosed() {
+
+ if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
+ LOC_LOGE("Null GNSS interface");
+ return false;
+ }
+
+ mGnss->getGnssInterface()->agpsDataConnClosed(LOC_AGPS_TYPE_SUPL);
+ return true;
+}
+
+Return<bool> AGnss::dataConnFailed() {
+
+ if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
+ LOC_LOGE("Null GNSS interface");
+ return false;
+ }
+
+ mGnss->getGnssInterface()->agpsDataConnFailed(LOC_AGPS_TYPE_SUPL);
+ return true;
+}
+
+Return<bool> AGnss::dataConnOpen(const hidl_string& apn,
+ IAGnss::ApnIpType apnIpType) {
+
+ if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){
+ LOC_LOGE("Null GNSS interface");
+ return false;
+ }
+
+ /* Validate */
+ if(apn.empty()){
+ LOC_LOGE("Invalid APN");
+ return false;
+ }
+
+ LOC_LOGD("dataConnOpen APN name = [%s]", apn.c_str());
+
+ mGnss->getGnssInterface()->agpsDataConnOpen(
+ LOC_AGPS_TYPE_SUPL, apn.c_str(), apn.size(), (int)apnIpType);
+ return true;
+}
+
+Return<bool> AGnss::setServer(IAGnssCallback::AGnssType type,
+ const hidl_string& hostname,
+ int32_t port) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT;
+ config.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer);
+ if (type == IAGnssCallback::AGnssType::TYPE_SUPL) {
+ config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL;
+ } else if (type == IAGnssCallback::AGnssType::TYPE_C2K) {
+ config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_C2K;
+ } else {
+ LOC_LOGE("%s]: invalid AGnssType: %d", __FUNCTION__, static_cast<int>(type));
+ return false;
+ }
+ config.assistanceServer.hostName = strdup(hostname.c_str());
+ config.assistanceServer.port = port;
+ return mGnss->updateConfiguration(config);
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/AGnss.h b/msm8998/android/AGnss.h
new file mode 100644
index 0000000..f4216b0
--- /dev/null
+++ b/msm8998/android/AGnss.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H
+#define ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H
+
+#include <android/hardware/gnss/1.0/IAGnss.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IAGnss;
+using ::android::hardware::gnss::V1_0::IAGnssCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Gnss;
+struct AGnss : public IAGnss {
+
+ AGnss(Gnss* gnss);
+ ~AGnss() = default;
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IAGnss interface follow.
+ * These declarations were generated from IAGnss.hal.
+ */
+ Return<void> setCallback(const sp<IAGnssCallback>& callback) override;
+
+ Return<bool> dataConnClosed() override;
+
+ Return<bool> dataConnFailed() override;
+
+ Return<bool> dataConnOpen(const hidl_string& apn,
+ IAGnss::ApnIpType apnIpType) override;
+
+ Return<bool> setServer(IAGnssCallback::AGnssType type,
+ const hidl_string& hostname, int32_t port) override;
+
+ /* Data call setup callback passed down to GNSS HAL implementation */
+ static void agnssStatusIpV4Cb(IAGnssCallback::AGnssStatusIpV4 status);
+
+ private:
+ Gnss* mGnss = nullptr;
+ static sp<IAGnssCallback> sAGnssCbIface;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H
diff --git a/msm8998/android/Android.mk b/msm8998/android/Android.mk
new file mode 100644
index 0000000..e359e88
--- /dev/null
+++ b/msm8998/android/Android.mk
@@ -0,0 +1,76 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.gnss@1.0-impl-qti
+LOCAL_MODULE_OWNER := qti
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_SRC_FILES := \
+ AGnss.cpp \
+ Gnss.cpp \
+ GnssBatching.cpp \
+ GnssGeofencing.cpp \
+ GnssMeasurement.cpp \
+ GnssNi.cpp \
+ GnssConfiguration.cpp \
+
+LOCAL_SRC_FILES += \
+ location_api/LocationUtil.cpp \
+ location_api/GnssAPIClient.cpp \
+ location_api/GeofenceAPIClient.cpp \
+ location_api/FlpAPIClient.cpp \
+ location_api/GnssMeasurementAPIClient.cpp \
+
+LOCAL_C_INCLUDES:= \
+ $(LOCAL_PATH)/location_api \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ $(TARGET_OUT_HEADERS)/libloc_pla \
+ $(TARGET_OUT_HEADERS)/liblocation_api \
+
+LOCAL_SHARED_LIBRARIES := \
+ liblog \
+ libhidlbase \
+ libhidltransport \
+ libhwbinder \
+ libutils \
+ android.hardware.gnss@1.0 \
+
+LOCAL_SHARED_LIBRARIES += \
+ libloc_core \
+ libgps.utils \
+ libdl \
+ libloc_pla \
+ liblocation_api \
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := android.hardware.gnss@1.0-service-qti
+LOCAL_MODULE_OWNER := qti
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_INIT_RC := android.hardware.gnss@1.0-service-qti.rc
+LOCAL_SRC_FILES := \
+ service.cpp \
+
+LOCAL_C_INCLUDES:= \
+ $(LOCAL_PATH)/location_api \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ $(TARGET_OUT_HEADERS)/libloc_pla \
+ $(TARGET_OUT_HEADERS)/liblocation_api \
+
+
+LOCAL_SHARED_LIBRARIES := \
+ liblog \
+ libcutils \
+ libdl \
+ libbase \
+ libutils \
+
+LOCAL_SHARED_LIBRARIES += \
+ libhwbinder \
+ libhidlbase \
+ libhidltransport \
+ android.hardware.gnss@1.0 \
+
+include $(BUILD_EXECUTABLE)
diff --git a/msm8998/android/Gnss.cpp b/msm8998/android/Gnss.cpp
new file mode 100644
index 0000000..1412883
--- /dev/null
+++ b/msm8998/android/Gnss.cpp
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_GnssInterface"
+
+#include <log_util.h>
+#include <dlfcn.h>
+#include "Gnss.h"
+typedef void* (getLocationInterface)();
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who) {
+ LOC_LOGE("%s] service died. cookie: %llu, who: %p",
+ __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
+ if (mGnss != nullptr) {
+ mGnss->stop();
+ mGnss->cleanup();
+ }
+}
+
+Gnss::Gnss() {
+ ENTRY_LOG_CALLFLOW();
+ // clear pending GnssConfig
+ memset(&mPendingConfig, 0, sizeof(GnssConfig));
+
+ mGnssDeathRecipient = new GnssDeathRecipient(this);
+}
+
+Gnss::~Gnss() {
+ ENTRY_LOG_CALLFLOW();
+ if (mApi != nullptr) {
+ delete mApi;
+ mApi = nullptr;
+ }
+}
+
+GnssAPIClient* Gnss::getApi() {
+ if (mApi == nullptr && (mGnssCbIface != nullptr || mGnssNiCbIface != nullptr)) {
+ mApi = new GnssAPIClient(mGnssCbIface, mGnssNiCbIface);
+ if (mApi == nullptr) {
+ LOC_LOGE("%s] faild to create GnssAPIClient", __FUNCTION__);
+ return mApi;
+ }
+
+ if (mPendingConfig.size == sizeof(GnssConfig)) {
+ // we have pending GnssConfig
+ mApi->gnssConfigurationUpdate(mPendingConfig);
+ // clear size to invalid mPendingConfig
+ mPendingConfig.size = 0;
+ if (mPendingConfig.assistanceServer.hostName != nullptr) {
+ free((void*)mPendingConfig.assistanceServer.hostName);
+ }
+ }
+ }
+ if (mApi == nullptr) {
+ LOC_LOGW("%s] GnssAPIClient is not ready", __FUNCTION__);
+ }
+ return mApi;
+}
+
+GnssInterface* Gnss::getGnssInterface() {
+ static bool getGnssInterfaceFailed = false;
+ if (nullptr == mGnssInterface && !getGnssInterfaceFailed) {
+ LOC_LOGD("%s]: loading libgnss.so::getGnssInterface ...", __func__);
+ getLocationInterface* getter = NULL;
+ const char *error;
+ dlerror();
+ void *handle = dlopen("libgnss.so", RTLD_NOW);
+ if (NULL == handle || (error = dlerror()) != NULL) {
+ LOC_LOGW("dlopen for libgnss.so failed, error = %s", error);
+ } else {
+ getter = (getLocationInterface*)dlsym(handle, "getGnssInterface");
+ if ((error = dlerror()) != NULL) {
+ LOC_LOGW("dlsym for libgnss.so::getGnssInterface failed, error = %s", error);
+ getter = NULL;
+ }
+ }
+
+ if (NULL == getter) {
+ getGnssInterfaceFailed = true;
+ } else {
+ mGnssInterface = (GnssInterface*)(*getter)();
+ }
+ }
+ return mGnssInterface;
+}
+
+Return<bool> Gnss::setCallback(const sp<IGnssCallback>& callback) {
+ ENTRY_LOG_CALLFLOW();
+ if (mGnssCbIface != nullptr) {
+ mGnssCbIface->unlinkToDeath(mGnssDeathRecipient);
+ }
+ mGnssCbIface = callback;
+ if (mGnssCbIface != nullptr) {
+ mGnssCbIface->linkToDeath(mGnssDeathRecipient, 0 /*cookie*/);
+ }
+
+ GnssAPIClient* api = getApi();
+ if (api != nullptr) {
+ api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface);
+ api->locAPIEnable(LOCATION_TECHNOLOGY_TYPE_GNSS);
+ }
+ return true;
+}
+
+Return<bool> Gnss::setGnssNiCb(const sp<IGnssNiCallback>& callback) {
+ ENTRY_LOG_CALLFLOW();
+ mGnssNiCbIface = callback;
+ GnssAPIClient* api = getApi();
+ if (api != nullptr) {
+ api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface);
+ }
+ return true;
+}
+
+Return<bool> Gnss::updateConfiguration(GnssConfig& gnssConfig) {
+ ENTRY_LOG_CALLFLOW();
+ GnssAPIClient* api = getApi();
+ if (api) {
+ api->locAPIGnssUpdateConfig(gnssConfig);
+ } else if (gnssConfig.flags != 0) {
+ // api is not ready yet, update mPendingConfig with gnssConfig
+ mPendingConfig.size = sizeof(GnssConfig);
+
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT;
+ mPendingConfig.gpsLock = gnssConfig.gpsLock;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT;
+ mPendingConfig.suplVersion = gnssConfig.suplVersion;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT;
+ mPendingConfig.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer);
+ mPendingConfig.assistanceServer.type = gnssConfig.assistanceServer.type;
+ if (mPendingConfig.assistanceServer.hostName != nullptr) {
+ free((void*)mPendingConfig.assistanceServer.hostName);
+ mPendingConfig.assistanceServer.hostName =
+ strdup(gnssConfig.assistanceServer.hostName);
+ }
+ mPendingConfig.assistanceServer.port = gnssConfig.assistanceServer.port;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT;
+ mPendingConfig.lppProfile = gnssConfig.lppProfile;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT;
+ mPendingConfig.lppeControlPlaneMask = gnssConfig.lppeControlPlaneMask;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT;
+ mPendingConfig.lppeUserPlaneMask = gnssConfig.lppeUserPlaneMask;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT;
+ mPendingConfig.aGlonassPositionProtocolMask = gnssConfig.aGlonassPositionProtocolMask;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT;
+ mPendingConfig.emergencyPdnForEmergencySupl = gnssConfig.emergencyPdnForEmergencySupl;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT;
+ mPendingConfig.suplEmergencyServices = gnssConfig.suplEmergencyServices;
+ }
+ if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) {
+ mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_MODE_BIT;
+ mPendingConfig.suplModeMask = gnssConfig.suplModeMask;
+ }
+ }
+ return true;
+}
+
+Return<bool> Gnss::start() {
+ ENTRY_LOG_CALLFLOW();
+ bool retVal = false;
+ GnssAPIClient* api = getApi();
+ if (api) {
+ retVal = api->gnssStart();
+ }
+ return retVal;
+}
+
+Return<bool> Gnss::stop() {
+ ENTRY_LOG_CALLFLOW();
+ bool retVal = false;
+ GnssAPIClient* api = getApi();
+ if (api) {
+ retVal = api->gnssStop();
+ }
+ return retVal;
+}
+
+Return<void> Gnss::cleanup() {
+ ENTRY_LOG_CALLFLOW();
+
+ if (mApi != nullptr) {
+ mApi->locAPIDisable();
+ }
+
+ return Void();
+}
+
+Return<bool> Gnss::injectLocation(double latitudeDegrees,
+ double longitudeDegrees,
+ float accuracyMeters) {
+ ENTRY_LOG_CALLFLOW();
+ GnssInterface* gnssInterface = getGnssInterface();
+ if (nullptr != gnssInterface) {
+ gnssInterface->injectLocation(latitudeDegrees, longitudeDegrees, accuracyMeters);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+Return<bool> Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs,
+ int32_t uncertaintyMs) {
+ ENTRY_LOG_CALLFLOW();
+ GnssInterface* gnssInterface = getGnssInterface();
+ if (nullptr != gnssInterface) {
+ gnssInterface->injectTime(timeMs, timeReferenceMs, uncertaintyMs);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+Return<void> Gnss::deleteAidingData(IGnss::GnssAidingData aidingDataFlags) {
+ ENTRY_LOG_CALLFLOW();
+ GnssAPIClient* api = getApi();
+ if (api) {
+ api->gnssDeleteAidingData(aidingDataFlags);
+ }
+ return Void();
+}
+
+Return<bool> Gnss::setPositionMode(IGnss::GnssPositionMode mode,
+ IGnss::GnssPositionRecurrence recurrence,
+ uint32_t minIntervalMs,
+ uint32_t preferredAccuracyMeters,
+ uint32_t preferredTimeMs) {
+ ENTRY_LOG_CALLFLOW();
+ bool retVal = false;
+ GnssAPIClient* api = getApi();
+ if (api) {
+ retVal = api->gnssSetPositionMode(mode, recurrence, minIntervalMs,
+ preferredAccuracyMeters, preferredTimeMs);
+ }
+ return retVal;
+}
+
+Return<sp<IAGnss>> Gnss::getExtensionAGnss() {
+ ENTRY_LOG_CALLFLOW();
+ mAGnssIface = new AGnss(this);
+ return mAGnssIface;
+}
+
+Return<sp<IGnssNi>> Gnss::getExtensionGnssNi() {
+ ENTRY_LOG_CALLFLOW();
+ mGnssNi = new GnssNi(this);
+ return mGnssNi;
+}
+
+Return<sp<IGnssMeasurement>> Gnss::getExtensionGnssMeasurement() {
+ ENTRY_LOG_CALLFLOW();
+ mGnssMeasurement = new GnssMeasurement();
+ return mGnssMeasurement;
+}
+
+Return<sp<IGnssConfiguration>> Gnss::getExtensionGnssConfiguration() {
+ ENTRY_LOG_CALLFLOW();
+ mGnssConfig = new GnssConfiguration(this);
+ return mGnssConfig;
+}
+
+Return<sp<IGnssGeofencing>> Gnss::getExtensionGnssGeofencing() {
+ ENTRY_LOG_CALLFLOW();
+ mGnssGeofencingIface = new GnssGeofencing();
+ return mGnssGeofencingIface;
+}
+
+Return<sp<IGnssBatching>> Gnss::getExtensionGnssBatching() {
+ mGnssBatching = new GnssBatching();
+ return mGnssBatching;
+}
+
+IGnss* HIDL_FETCH_IGnss(const char* hal) {
+ ENTRY_LOG_CALLFLOW();
+ IGnss* iface = nullptr;
+ iface = new Gnss();
+ if (iface == nullptr) {
+ LOC_LOGE("%s]: failed to get %s", __FUNCTION__, hal);
+ }
+ return iface;
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/Gnss.h b/msm8998/android/Gnss.h
new file mode 100644
index 0000000..b338b08
--- /dev/null
+++ b/msm8998/android/Gnss.h
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSS_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSS_H
+
+#include <AGnss.h>
+#include <GnssBatching.h>
+#include <GnssConfiguration.h>
+#include <GnssGeofencing.h>
+#include <GnssMeasurement.h>
+#include <GnssNi.h>
+
+#include <android/hardware/gnss/1.0/IGnss.h>
+#include <hidl/Status.h>
+
+#include <GnssAPIClient.h>
+#include <location_interface.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Gnss : public IGnss {
+ Gnss();
+ ~Gnss();
+
+ // registerAsService will call interfaceChain to determine the version of service
+ /* comment this out until we know really how to manipulate hidl version
+ using interfaceChain_cb = std::function<
+ void(const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& descriptors)>;
+ virtual ::android::hardware::Return<void> interfaceChain(interfaceChain_cb _hidl_cb) override {
+ _hidl_cb({
+ "android.hardware.gnss@1.1::IGnss",
+ ::android::hidl::base::V1_0::IBase::descriptor,
+ });
+ return ::android::hardware::Void();
+ }
+ */
+
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IGnss follow.
+ * These declarations were generated from Gnss.hal.
+ */
+ Return<bool> setCallback(const sp<IGnssCallback>& callback) override;
+ Return<bool> start() override;
+ Return<bool> stop() override;
+ Return<void> cleanup() override;
+ Return<bool> injectLocation(double latitudeDegrees,
+ double longitudeDegrees,
+ float accuracyMeters) override;
+ Return<bool> injectTime(int64_t timeMs,
+ int64_t timeReferenceMs,
+ int32_t uncertaintyMs) override;
+ Return<void> deleteAidingData(IGnss::GnssAidingData aidingDataFlags) override;
+ Return<bool> setPositionMode(IGnss::GnssPositionMode mode,
+ IGnss::GnssPositionRecurrence recurrence,
+ uint32_t minIntervalMs,
+ uint32_t preferredAccuracyMeters,
+ uint32_t preferredTimeMs) override;
+ Return<sp<IAGnss>> getExtensionAGnss() override;
+ Return<sp<IGnssNi>> getExtensionGnssNi() override;
+ Return<sp<IGnssMeasurement>> getExtensionGnssMeasurement() override;
+ Return<sp<IGnssConfiguration>> getExtensionGnssConfiguration() override;
+ Return<sp<IGnssGeofencing>> getExtensionGnssGeofencing() override;
+ Return<sp<IGnssBatching>> getExtensionGnssBatching() override;
+
+ inline Return<sp<IAGnssRil>> getExtensionAGnssRil() override {
+ return nullptr;
+ }
+
+ inline Return<sp<IGnssNavigationMessage>> getExtensionGnssNavigationMessage() override {
+ return nullptr;
+ }
+
+ inline Return<sp<IGnssXtra>> getExtensionXtra() override {
+ return nullptr;
+ }
+
+ inline Return<sp<IGnssDebug>> getExtensionGnssDebug() override {
+ return nullptr;
+ }
+
+ // These methods are not part of the IGnss base class.
+ GnssAPIClient* getApi();
+ Return<bool> setGnssNiCb(const sp<IGnssNiCallback>& niCb);
+ Return<bool> updateConfiguration(GnssConfig& gnssConfig);
+ GnssInterface* getGnssInterface();
+
+ private:
+ struct GnssDeathRecipient : hidl_death_recipient {
+ GnssDeathRecipient(sp<Gnss> gnss) : mGnss(gnss) {
+ }
+ ~GnssDeathRecipient() = default;
+ virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override;
+ sp<Gnss> mGnss;
+ };
+
+ private:
+ sp<GnssDeathRecipient> mGnssDeathRecipient = nullptr;
+
+ sp<AGnss> mAGnssIface = nullptr;
+ sp<GnssNi> mGnssNi = nullptr;
+ sp<GnssMeasurement> mGnssMeasurement = nullptr;
+ sp<GnssConfiguration> mGnssConfig = nullptr;
+ sp<GnssGeofencing> mGnssGeofencingIface = nullptr;
+ sp<GnssBatching> mGnssBatching = nullptr;
+
+ GnssAPIClient* mApi = nullptr;
+ sp<IGnssCallback> mGnssCbIface = nullptr;
+ sp<IGnssNiCallback> mGnssNiCbIface = nullptr;
+ GnssConfig mPendingConfig;
+ GnssInterface* mGnssInterface = nullptr;
+};
+
+extern "C" IGnss* HIDL_FETCH_IGnss(const char* name);
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSS_H
diff --git a/msm8998/android/GnssBatching.cpp b/msm8998/android/GnssBatching.cpp
new file mode 100644
index 0000000..5eff819
--- /dev/null
+++ b/msm8998/android/GnssBatching.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_GnssBatchingInterface"
+
+#include <log_util.h>
+#include <FlpAPIClient.h>
+#include "GnssBatching.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void GnssBatching::GnssBatchingDeathRecipient::serviceDied(
+ uint64_t cookie, const wp<IBase>& who) {
+ LOC_LOGE("%s] service died. cookie: %llu, who: %p",
+ __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
+ if (mGnssBatching != nullptr) {
+ mGnssBatching->stop();
+ mGnssBatching->cleanup();
+ }
+}
+
+GnssBatching::GnssBatching() : mApi(nullptr) {
+ mGnssBatchingDeathRecipient = new GnssBatchingDeathRecipient(this);
+}
+
+GnssBatching::~GnssBatching() {
+ if (mApi != nullptr) {
+ delete mApi;
+ mApi = nullptr;
+ }
+}
+
+
+// Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow.
+Return<bool> GnssBatching::init(const sp<IGnssBatchingCallback>& callback) {
+ if (mApi != nullptr) {
+ LOC_LOGE("%s]: mApi is NOT nullptr", __FUNCTION__);
+ return false;
+ }
+
+ mApi = new FlpAPIClient(callback);
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: failed to create mApi", __FUNCTION__);
+ return false;
+ }
+
+ if (mGnssBatchingCbIface != nullptr) {
+ mGnssBatchingCbIface->unlinkToDeath(mGnssBatchingDeathRecipient);
+ }
+ mGnssBatchingCbIface = callback;
+ if (mGnssBatchingCbIface != nullptr) {
+ mGnssBatchingCbIface->linkToDeath(mGnssBatchingDeathRecipient, 0 /*cookie*/);
+ }
+
+ return true;
+}
+
+Return<uint16_t> GnssBatching::getBatchSize() {
+ uint16_t ret = 0;
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ ret = mApi->flpGetBatchSize();
+ }
+ return ret;
+}
+
+Return<bool> GnssBatching::start(const IGnssBatching::Options& options) {
+ bool ret = false;
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ ret = mApi->flpStartSession(options);
+ }
+ return ret;
+}
+
+Return<void> GnssBatching::flush() {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ mApi->flpFlushBatchedLocations();
+ }
+ return Void();
+}
+
+Return<bool> GnssBatching::stop() {
+ bool ret = false;
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ ret = mApi->flpStopSession();
+ }
+ return ret;
+}
+
+Return<void> GnssBatching::cleanup() {
+ if (mGnssBatchingCbIface != nullptr) {
+ mGnssBatchingCbIface->unlinkToDeath(mGnssBatchingDeathRecipient);
+ }
+ return Void();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/GnssBatching.h b/msm8998/android/GnssBatching.h
new file mode 100644
index 0000000..b46fae8
--- /dev/null
+++ b/msm8998/android/GnssBatching.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H
+
+#include <android/hardware/gnss/1.0/IGnssBatching.h>
+#include <hidl/Status.h>
+
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssBatching;
+using ::android::hardware::gnss::V1_0::IGnssBatchingCallback;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::sp;
+
+class FlpAPIClient;
+struct GnssBatching : public IGnssBatching {
+ GnssBatching();
+ ~GnssBatching();
+
+ // Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow.
+ Return<bool> init(const sp<IGnssBatchingCallback>& callback) override;
+ Return<uint16_t> getBatchSize() override;
+ Return<bool> start(const IGnssBatching::Options& options ) override;
+ Return<void> flush() override;
+ Return<bool> stop() override;
+ Return<void> cleanup() override;
+
+ private:
+ struct GnssBatchingDeathRecipient : hidl_death_recipient {
+ GnssBatchingDeathRecipient(sp<GnssBatching> gnssBatching) :
+ mGnssBatching(gnssBatching) {
+ }
+ ~GnssBatchingDeathRecipient() = default;
+ virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override;
+ sp<GnssBatching> mGnssBatching;
+ };
+
+ private:
+ sp<GnssBatchingDeathRecipient> mGnssBatchingDeathRecipient = nullptr;
+ sp<IGnssBatchingCallback> mGnssBatchingCbIface = nullptr;
+ FlpAPIClient* mApi = nullptr;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H
diff --git a/msm8998/android/GnssConfiguration.cpp b/msm8998/android/GnssConfiguration.cpp
new file mode 100644
index 0000000..591a01a
--- /dev/null
+++ b/msm8998/android/GnssConfiguration.cpp
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_GnssConfigurationInterface"
+
+#include <log_util.h>
+#include "Gnss.h"
+#include "GnssConfiguration.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+GnssConfiguration::GnssConfiguration(Gnss* gnss) : mGnss(gnss) {
+}
+
+// Methods from ::android::hardware::gps::V1_0::IGnssConfiguration follow.
+Return<bool> GnssConfiguration::setSuplEs(bool enabled) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT;
+ config.suplEmergencyServices = static_cast<GnssConfigSuplEmergencyServices>(enabled);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setSuplVersion(uint32_t version) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT;
+ config.suplVersion = static_cast<GnssConfigSuplVersion>(version);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setSuplMode(uint8_t mode) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_SUPL_MODE_BIT;
+ config.suplModeMask = static_cast<GnssConfigSuplModeMask>(mode);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setLppProfile(uint8_t lppProfile) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT;
+ config.lppProfile = static_cast<GnssConfigLppProfile>(lppProfile);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setGlonassPositioningProtocol(uint8_t protocol) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT;
+ config.aGlonassPositionProtocolMask =
+ static_cast<GnssConfigAGlonassPositionProtocolMask>(protocol);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setGpsLock(uint8_t lock) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT;
+ config.gpsLock = static_cast<GnssConfigGpsLock>(lock);
+
+ return mGnss->updateConfiguration(config);
+}
+
+Return<bool> GnssConfiguration::setEmergencySuplPdn(bool enabled) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return false;
+ }
+
+ GnssConfig config;
+ memset(&config, 0, sizeof(GnssConfig));
+ config.size = sizeof(GnssConfig);
+ config.flags = GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT;
+ config.emergencyPdnForEmergencySupl =
+ static_cast<GnssConfigEmergencyPdnForEmergencySupl>(enabled);
+
+ return mGnss->updateConfiguration(config);
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/GnssConfiguration.h b/msm8998/android/GnssConfiguration.h
new file mode 100644
index 0000000..f9ea423
--- /dev/null
+++ b/msm8998/android/GnssConfiguration.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+
+ /* Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H
+
+#include <android/hardware/gnss/1.0/IGnssConfiguration.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssConfiguration;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+/*
+ * Interface for passing GNSS configuration info from platform to HAL.
+ */
+struct Gnss;
+struct GnssConfiguration : public IGnssConfiguration {
+ GnssConfiguration(Gnss* gnss);
+ ~GnssConfiguration() = default;
+
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IGnssConfiguration follow.
+ * These declarations were generated from IGnssConfiguration.hal.
+ */
+ Return<bool> setSuplVersion(uint32_t version) override;
+ Return<bool> setSuplMode(uint8_t mode) override;
+ Return<bool> setSuplEs(bool enabled) override;
+ Return<bool> setLppProfile(uint8_t lppProfile) override;
+ Return<bool> setGlonassPositioningProtocol(uint8_t protocol) override;
+ Return<bool> setEmergencySuplPdn(bool enable) override;
+ Return<bool> setGpsLock(uint8_t lock) override;
+
+ private:
+ Gnss* mGnss = nullptr;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H
diff --git a/msm8998/android/GnssGeofencing.cpp b/msm8998/android/GnssGeofencing.cpp
new file mode 100644
index 0000000..035a092
--- /dev/null
+++ b/msm8998/android/GnssGeofencing.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "GnssHal_GnssGeofencing"
+
+#include <log_util.h>
+#include <GeofenceAPIClient.h>
+#include "GnssGeofencing.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void GnssGeofencing::GnssGeofencingDeathRecipient::serviceDied(
+ uint64_t cookie, const wp<IBase>& who) {
+ LOC_LOGE("%s] service died. cookie: %llu, who: %p",
+ __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
+ if (mGnssGeofencing != nullptr) {
+ mGnssGeofencing->removeAllGeofences();
+ }
+}
+
+GnssGeofencing::GnssGeofencing() : mApi(nullptr) {
+ mGnssGeofencingDeathRecipient = new GnssGeofencingDeathRecipient(this);
+}
+
+GnssGeofencing::~GnssGeofencing() {
+ if (mApi != nullptr) {
+ delete mApi;
+ mApi = nullptr;
+ }
+}
+
+// Methods from ::android::hardware::gnss::V1_0::IGnssGeofencing follow.
+Return<void> GnssGeofencing::setCallback(const sp<IGnssGeofenceCallback>& callback) {
+ if (mApi != nullptr) {
+ LOC_LOGE("%s]: mApi is NOT nullptr", __FUNCTION__);
+ return Void();
+ }
+
+ mApi = new GeofenceAPIClient(callback);
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: failed to create mApi", __FUNCTION__);
+ }
+
+ if (mGnssGeofencingCbIface != nullptr) {
+ mGnssGeofencingCbIface->unlinkToDeath(mGnssGeofencingDeathRecipient);
+ }
+ mGnssGeofencingCbIface = callback;
+ if (mGnssGeofencingCbIface != nullptr) {
+ mGnssGeofencingCbIface->linkToDeath(mGnssGeofencingDeathRecipient, 0 /*cookie*/);
+ }
+
+ return Void();
+}
+
+Return<void> GnssGeofencing::addGeofence(
+ int32_t geofenceId,
+ double latitudeDegrees,
+ double longitudeDegrees,
+ double radiusMeters,
+ IGnssGeofenceCallback::GeofenceTransition lastTransition,
+ int32_t monitorTransitions,
+ uint32_t notificationResponsivenessMs,
+ uint32_t unknownTimerMs) {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ mApi->geofenceAdd(
+ geofenceId,
+ latitudeDegrees,
+ longitudeDegrees,
+ radiusMeters,
+ static_cast<int32_t>(lastTransition),
+ monitorTransitions,
+ notificationResponsivenessMs,
+ unknownTimerMs);
+ }
+ return Void();
+}
+
+Return<void> GnssGeofencing::pauseGeofence(int32_t geofenceId) {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ mApi->geofencePause(geofenceId);
+ }
+ return Void();
+}
+
+Return<void> GnssGeofencing::resumeGeofence(int32_t geofenceId, int32_t monitorTransitions) {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ mApi->geofenceResume(geofenceId, monitorTransitions);
+ }
+ return Void();
+}
+
+Return<void> GnssGeofencing::removeGeofence(int32_t geofenceId) {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ } else {
+ mApi->geofenceRemove(geofenceId);
+ }
+ return Void();
+}
+
+Return<void> GnssGeofencing::removeAllGeofences() {
+ if (mApi == nullptr) {
+ LOC_LOGD("%s]: mApi is nullptr, do nothing", __FUNCTION__);
+ } else {
+ mApi->geofenceRemoveAll();
+ }
+ return Void();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/GnssGeofencing.h b/msm8998/android/GnssGeofencing.h
new file mode 100644
index 0000000..7af5f91
--- /dev/null
+++ b/msm8998/android/GnssGeofencing.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H
+
+#include <android/hardware/gnss/1.0/IGnssGeofencing.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssGeofenceCallback;
+using ::android::hardware::gnss::V1_0::IGnssGeofencing;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+class GeofenceAPIClient;
+struct GnssGeofencing : public IGnssGeofencing {
+ GnssGeofencing();
+ ~GnssGeofencing();
+
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IGnssGeofencing follow.
+ * These declarations were generated from IGnssGeofencing.hal.
+ */
+ Return<void> setCallback(const sp<IGnssGeofenceCallback>& callback) override;
+ Return<void> addGeofence(int32_t geofenceId,
+ double latitudeDegrees,
+ double longitudeDegrees,
+ double radiusMeters,
+ IGnssGeofenceCallback::GeofenceTransition lastTransition,
+ int32_t monitorTransitions,
+ uint32_t notificationResponsivenessMs,
+ uint32_t unknownTimerMs) override;
+
+ Return<void> pauseGeofence(int32_t geofenceId) override;
+ Return<void> resumeGeofence(int32_t geofenceId, int32_t monitorTransitions) override;
+ Return<void> removeGeofence(int32_t geofenceId) override;
+
+ private:
+ // This method is not part of the IGnss base class.
+ // It is called by GnssGeofencingDeathRecipient to remove all geofences added so far.
+ Return<void> removeAllGeofences();
+
+ private:
+ struct GnssGeofencingDeathRecipient : hidl_death_recipient {
+ GnssGeofencingDeathRecipient(sp<GnssGeofencing> gnssGeofencing) :
+ mGnssGeofencing(gnssGeofencing) {
+ }
+ ~GnssGeofencingDeathRecipient() = default;
+ virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override;
+ sp<GnssGeofencing> mGnssGeofencing;
+ };
+
+ private:
+ sp<GnssGeofencingDeathRecipient> mGnssGeofencingDeathRecipient = nullptr;
+ sp<IGnssGeofenceCallback> mGnssGeofencingCbIface = nullptr;
+ GeofenceAPIClient* mApi = nullptr;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H
diff --git a/msm8998/android/GnssMeasurement.cpp b/msm8998/android/GnssMeasurement.cpp
new file mode 100644
index 0000000..bc07265
--- /dev/null
+++ b/msm8998/android/GnssMeasurement.cpp
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_GnssMeasurementInterface"
+
+#include <log_util.h>
+#include <GnssMeasurementAPIClient.h>
+#include "GnssMeasurement.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void GnssMeasurement::GnssMeasurementDeathRecipient::serviceDied(
+ uint64_t cookie, const wp<IBase>& who) {
+ LOC_LOGE("%s] service died. cookie: %llu, who: %p",
+ __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
+ if (mGnssMeasurement != nullptr) {
+ mGnssMeasurement->close();
+ }
+}
+
+GnssMeasurement::GnssMeasurement() {
+ mGnssMeasurementDeathRecipient = new GnssMeasurementDeathRecipient(this);
+ mApi = new GnssMeasurementAPIClient();
+}
+
+GnssMeasurement::~GnssMeasurement() {
+ if (mApi) {
+ delete mApi;
+ mApi = nullptr;
+ }
+}
+
+// Methods from ::android::hardware::gnss::V1_0::IGnssMeasurement follow.
+Return<IGnssMeasurement::GnssMeasurementStatus> GnssMeasurement::setCallback(
+ const sp<IGnssMeasurementCallback>& callback) {
+
+ Return<IGnssMeasurement::GnssMeasurementStatus> ret =
+ IGnssMeasurement::GnssMeasurementStatus::ERROR_GENERIC;
+ if (mGnssMeasurementCbIface != nullptr) {
+ LOC_LOGE("%s]: GnssMeasurementCallback is already set", __FUNCTION__);
+ return IGnssMeasurement::GnssMeasurementStatus::ERROR_ALREADY_INIT;
+ }
+
+ if (callback == nullptr) {
+ LOC_LOGE("%s]: callback is nullptr", __FUNCTION__);
+ return ret;
+ }
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ return ret;
+ }
+
+ mGnssMeasurementCbIface = callback;
+ mGnssMeasurementCbIface->linkToDeath(mGnssMeasurementDeathRecipient, 0 /*cookie*/);
+
+ return mApi->gnssMeasurementSetCallback(callback);
+}
+
+Return<void> GnssMeasurement::close() {
+ if (mApi == nullptr) {
+ LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__);
+ return Void();
+ }
+
+ if (mGnssMeasurementCbIface != nullptr) {
+ mGnssMeasurementCbIface->unlinkToDeath(mGnssMeasurementDeathRecipient);
+ mGnssMeasurementCbIface = nullptr;
+ }
+ mApi->gnssMeasurementClose();
+
+ return Void();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/GnssMeasurement.h b/msm8998/android/GnssMeasurement.h
new file mode 100644
index 0000000..cd364c3
--- /dev/null
+++ b/msm8998/android/GnssMeasurement.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H
+
+#include <android/hardware/gnss/1.0/IGnssMeasurement.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssMeasurement;
+using ::android::hardware::gnss::V1_0::IGnssMeasurementCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+class GnssMeasurementAPIClient;
+struct GnssMeasurement : public IGnssMeasurement {
+ GnssMeasurement();
+ ~GnssMeasurement();
+
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IGnssMeasurement follow.
+ * These declarations were generated from IGnssMeasurement.hal.
+ */
+ Return<GnssMeasurementStatus> setCallback(
+ const sp<IGnssMeasurementCallback>& callback) override;
+ Return<void> close() override;
+
+ private:
+ struct GnssMeasurementDeathRecipient : hidl_death_recipient {
+ GnssMeasurementDeathRecipient(sp<GnssMeasurement> gnssMeasurement) :
+ mGnssMeasurement(gnssMeasurement) {
+ }
+ ~GnssMeasurementDeathRecipient() = default;
+ virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override;
+ sp<GnssMeasurement> mGnssMeasurement;
+ };
+
+ private:
+ sp<GnssMeasurementDeathRecipient> mGnssMeasurementDeathRecipient = nullptr;
+ sp<IGnssMeasurementCallback> mGnssMeasurementCbIface = nullptr;
+ GnssMeasurementAPIClient* mApi;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H
diff --git a/msm8998/android/GnssNi.cpp b/msm8998/android/GnssNi.cpp
new file mode 100644
index 0000000..4437932
--- /dev/null
+++ b/msm8998/android/GnssNi.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "LocSvc_GnssNiInterface"
+
+#include <log_util.h>
+#include "Gnss.h"
+#include "GnssNi.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void GnssNi::GnssNiDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who) {
+ LOC_LOGE("%s] service died. cookie: %llu, who: %p",
+ __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
+ // we do nothing here
+ // Gnss::GnssDeathRecipient will stop the session
+}
+
+GnssNi::GnssNi(Gnss* gnss) : mGnss(gnss) {
+ mGnssNiDeathRecipient = new GnssNiDeathRecipient(this);
+}
+
+// Methods from ::android::hardware::gnss::V1_0::IGnssNi follow.
+Return<void> GnssNi::setCallback(const sp<IGnssNiCallback>& callback) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return Void();
+ }
+
+ mGnss->setGnssNiCb(callback);
+
+ if (mGnssNiCbIface != nullptr) {
+ mGnssNiCbIface->unlinkToDeath(mGnssNiDeathRecipient);
+ }
+ mGnssNiCbIface = callback;
+ if (mGnssNiCbIface != nullptr) {
+ mGnssNiCbIface->linkToDeath(mGnssNiDeathRecipient, 0 /*cookie*/);
+ }
+
+ return Void();
+}
+
+Return<void> GnssNi::respond(int32_t notifId, IGnssNiCallback::GnssUserResponseType userResponse) {
+ if (mGnss == nullptr) {
+ LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
+ return Void();
+ }
+
+ GnssAPIClient* api = mGnss->getApi();
+ if (api == nullptr) {
+ LOC_LOGE("%s]: api is nullptr", __FUNCTION__);
+ return Void();
+ }
+
+ api->gnssNiRespond(notifId, userResponse);
+
+ return Void();
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/GnssNi.h b/msm8998/android/GnssNi.h
new file mode 100644
index 0000000..f6fe0bb
--- /dev/null
+++ b/msm8998/android/GnssNi.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H
+#define ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H
+
+#include <android/hardware/gnss/1.0/IGnssNi.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssNi;
+using ::android::hardware::gnss::V1_0::IGnssNiCallback;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_string;
+using ::android::sp;
+
+struct Gnss;
+struct GnssNi : public IGnssNi {
+ GnssNi(Gnss* gnss);
+ ~GnssNi() = default;
+
+ /*
+ * Methods from ::android::hardware::gnss::V1_0::IGnssNi follow.
+ * These declarations were generated from IGnssNi.hal.
+ */
+ Return<void> setCallback(const sp<IGnssNiCallback>& callback) override;
+ Return<void> respond(int32_t notifId,
+ IGnssNiCallback::GnssUserResponseType userResponse) override;
+
+ private:
+ struct GnssNiDeathRecipient : hidl_death_recipient {
+ GnssNiDeathRecipient(sp<GnssNi> gnssNi) : mGnssNi(gnssNi) {
+ }
+ ~GnssNiDeathRecipient() = default;
+ virtual void serviceDied(uint64_t cookie, const wp<IBase>& who) override;
+ sp<GnssNi> mGnssNi;
+ };
+
+ private:
+ sp<GnssNiDeathRecipient> mGnssNiDeathRecipient = nullptr;
+ sp<IGnssNiCallback> mGnssNiCbIface = nullptr;
+ Gnss* mGnss = nullptr;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H
diff --git a/msm8998/android/android.hardware.gnss@1.0-service-qti.rc b/msm8998/android/android.hardware.gnss@1.0-service-qti.rc
new file mode 100644
index 0000000..7ba6460
--- /dev/null
+++ b/msm8998/android/android.hardware.gnss@1.0-service-qti.rc
@@ -0,0 +1,4 @@
+service gnss_service /system/bin/hw/android.hardware.gnss@1.0-service-qti
+ class main
+ user system
+ group system
diff --git a/msm8998/android/location_api/FlpAPIClient.cpp b/msm8998/android/location_api/FlpAPIClient.cpp
new file mode 100644
index 0000000..2fb8caa
--- /dev/null
+++ b/msm8998/android/location_api/FlpAPIClient.cpp
@@ -0,0 +1,182 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_FlpAPIClient"
+
+#include <log_util.h>
+#include <loc_cfg.h>
+
+#include "LocationUtil.h"
+#include "FlpAPIClient.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+static void convertBatchOption(const IGnssBatching::Options& in, LocationOptions& out,
+ LocationCapabilitiesMask mask);
+
+FlpAPIClient::FlpAPIClient(const sp<IGnssBatchingCallback>& callback) :
+ LocationAPIClientBase(),
+ mGnssBatchingCbIface(callback),
+ mDefaultId(42),
+ mLocationCapabilitiesMask(0)
+{
+ LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback);
+
+ LocationCallbacks locationCallbacks;
+ locationCallbacks.size = sizeof(LocationCallbacks);
+
+ locationCallbacks.trackingCb = nullptr;
+ locationCallbacks.batchingCb = nullptr;
+ if (mGnssBatchingCbIface != nullptr) {
+ locationCallbacks.batchingCb = [this](size_t count, Location* location) {
+ onBatchingCb(count, location);
+ };
+ }
+ locationCallbacks.geofenceBreachCb = nullptr;
+ locationCallbacks.geofenceStatusCb = nullptr;
+ locationCallbacks.gnssLocationInfoCb = nullptr;
+ locationCallbacks.gnssNiCb = nullptr;
+ locationCallbacks.gnssSvCb = nullptr;
+ locationCallbacks.gnssNmeaCb = nullptr;
+ locationCallbacks.gnssMeasurementsCb = nullptr;
+
+ locAPISetCallbacks(locationCallbacks);
+}
+
+FlpAPIClient::~FlpAPIClient()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+}
+
+int FlpAPIClient::flpGetBatchSize()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ return locAPIGetBatchSize();
+}
+
+int FlpAPIClient::flpStartSession(const IGnssBatching::Options& opts)
+{
+ LOC_LOGD("%s]: (%lld %d)", __FUNCTION__,
+ static_cast<long long>(opts.periodNanos), static_cast<uint8_t>(opts.flags));
+ int retVal = -1;
+ LocationOptions options;
+ convertBatchOption(opts, options, mLocationCapabilitiesMask);
+ uint32_t mode = 0;
+ if (opts.flags == static_cast<uint8_t>(IGnssBatching::Flag::WAKEUP_ON_FIFO_FULL)) {
+ mode = SESSION_MODE_ON_FULL;
+ }
+ if (locAPIStartSession(mDefaultId, mode, options) == LOCATION_ERROR_SUCCESS) {
+ retVal = 1;
+ }
+ return retVal;
+}
+
+int FlpAPIClient::flpUpdateSessionOptions(const IGnssBatching::Options& opts)
+{
+ LOC_LOGD("%s]: (%lld %d)", __FUNCTION__,
+ static_cast<long long>(opts.periodNanos), static_cast<uint8_t>(opts.flags));
+ int retVal = -1;
+ LocationOptions options;
+ convertBatchOption(opts, options, mLocationCapabilitiesMask);
+
+ uint32_t mode = 0;
+ if (opts.flags == static_cast<uint8_t>(IGnssBatching::Flag::WAKEUP_ON_FIFO_FULL)) {
+ mode = SESSION_MODE_ON_FULL;
+ }
+ if (locAPIUpdateSessionOptions(mDefaultId, mode, options) == LOCATION_ERROR_SUCCESS) {
+ retVal = 1;
+ }
+ return retVal;
+}
+
+int FlpAPIClient::flpStopSession()
+{
+ LOC_LOGD("%s]: ", __FUNCTION__);
+ int retVal = -1;
+ if (locAPIStopSession(mDefaultId) == LOCATION_ERROR_SUCCESS) {
+ retVal = 1;
+ }
+ return retVal;
+}
+
+void FlpAPIClient::flpGetBatchedLocation(int last_n_locations)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, last_n_locations);
+ locAPIGetBatchedLocations(last_n_locations);
+}
+
+void FlpAPIClient::flpFlushBatchedLocations()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ locAPIGetBatchedLocations(SIZE_MAX);
+}
+
+void FlpAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
+{
+ LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask);
+ mLocationCapabilitiesMask = capabilitiesMask;
+}
+
+void FlpAPIClient::onBatchingCb(size_t count, Location* location)
+{
+ LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, count);
+ if (mGnssBatchingCbIface != nullptr && count > 0) {
+ hidl_vec<GnssLocation> locationVec;
+ locationVec.resize(count);
+ for (size_t i = 0; i < count; i++) {
+ convertGnssLocation(location[i], locationVec[i]);
+ }
+ mGnssBatchingCbIface->gnssLocationBatchCb(locationVec);
+ }
+}
+
+static void convertBatchOption(const IGnssBatching::Options& in, LocationOptions& out,
+ LocationCapabilitiesMask mask)
+{
+ memset(&out, 0, sizeof(LocationOptions));
+ out.size = sizeof(LocationOptions);
+ out.minInterval = (uint32_t)(in.periodNanos / 1000000L);
+ out.minDistance = 0;
+ out.mode = GNSS_SUPL_MODE_STANDALONE;
+ if (mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)
+ out.mode = GNSS_SUPL_MODE_MSA;
+ if (mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT)
+ out.mode = GNSS_SUPL_MODE_MSB;
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/location_api/FlpAPIClient.h b/msm8998/android/location_api/FlpAPIClient.h
new file mode 100644
index 0000000..9f9be1e
--- /dev/null
+++ b/msm8998/android/location_api/FlpAPIClient.h
@@ -0,0 +1,77 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef FLP_API_CLINET_H
+#define FLP_API_CLINET_H
+
+#include <android/hardware/gnss/1.0/IGnssBatching.h>
+#include <android/hardware/gnss/1.0/IGnssBatchingCallback.h>
+#include <pthread.h>
+
+#include <LocationAPIClientBase.h>
+
+#define FLP_CONF_FILE "/etc/flp.conf"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+class FlpAPIClient : public LocationAPIClientBase
+{
+public:
+ FlpAPIClient(const sp<IGnssBatchingCallback>& callback);
+ ~FlpAPIClient();
+ int flpGetBatchSize();
+ int flpStartSession(const IGnssBatching::Options& options);
+ int flpUpdateSessionOptions(const IGnssBatching::Options& options);
+ int flpStopSession();
+ void flpGetBatchedLocation(int last_n_locations);
+ void flpFlushBatchedLocations();
+
+ inline LocationCapabilitiesMask flpGetCapabilities() { return mLocationCapabilitiesMask; }
+
+ // callbacks
+ void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final;
+ void onBatchingCb(size_t count, Location* location) final;
+
+private:
+ sp<IGnssBatchingCallback> mGnssBatchingCbIface;
+ uint32_t mDefaultId;
+ int mBatchSize;
+ LocationCapabilitiesMask mLocationCapabilitiesMask;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+#endif // FLP_API_CLINET_H
diff --git a/msm8998/android/location_api/GeofenceAPIClient.cpp b/msm8998/android/location_api/GeofenceAPIClient.cpp
new file mode 100644
index 0000000..5be1cff
--- /dev/null
+++ b/msm8998/android/location_api/GeofenceAPIClient.cpp
@@ -0,0 +1,245 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_GeofenceApiClient"
+
+#include <log_util.h>
+#include <loc_cfg.h>
+
+#include "LocationUtil.h"
+#include "GeofenceAPIClient.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+
+GeofenceAPIClient::GeofenceAPIClient(const sp<IGnssGeofenceCallback>& callback) :
+ LocationAPIClientBase(),
+ mGnssGeofencingCbIface(callback)
+{
+ LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback);
+
+ LocationCallbacks locationCallbacks;
+ locationCallbacks.size = sizeof(LocationCallbacks);
+
+ locationCallbacks.trackingCb = nullptr;
+ locationCallbacks.batchingCb = nullptr;
+
+ locationCallbacks.geofenceBreachCb = nullptr;
+ if (mGnssGeofencingCbIface != nullptr) {
+ locationCallbacks.geofenceBreachCb =
+ [this](GeofenceBreachNotification geofenceBreachNotification) {
+ onGeofenceBreachCb(geofenceBreachNotification);
+ };
+
+ locationCallbacks.geofenceStatusCb =
+ [this](GeofenceStatusNotification geofenceStatusNotification) {
+ onGeofenceStatusCb(geofenceStatusNotification);
+ };
+ }
+
+ locationCallbacks.gnssLocationInfoCb = nullptr;
+ locationCallbacks.gnssNiCb = nullptr;
+ locationCallbacks.gnssSvCb = nullptr;
+ locationCallbacks.gnssNmeaCb = nullptr;
+ locationCallbacks.gnssMeasurementsCb = nullptr;
+
+ locAPISetCallbacks(locationCallbacks);
+}
+
+void GeofenceAPIClient::geofenceAdd(uint32_t geofence_id, double latitude, double longitude,
+ double radius_meters, int32_t last_transition, int32_t monitor_transitions,
+ uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms)
+{
+ LOC_LOGD("%s]: (%d %f %f %f %d %d %d %d)", __FUNCTION__,
+ geofence_id, latitude, longitude, radius_meters,
+ last_transition, monitor_transitions, notification_responsiveness_ms, unknown_timer_ms);
+
+ GeofenceOption options;
+ memset(&options, 0, sizeof(GeofenceOption));
+ options.size = sizeof(GeofenceOption);
+ if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::ENTERED)
+ options.breachTypeMask |= GEOFENCE_BREACH_ENTER_BIT;
+ if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::EXITED)
+ options.breachTypeMask |= GEOFENCE_BREACH_EXIT_BIT;
+ options.responsiveness = notification_responsiveness_ms;
+
+ GeofenceInfo data;
+ data.size = sizeof(GeofenceInfo);
+ data.latitude = latitude;
+ data.longitude = longitude;
+ data.radius = radius_meters;
+
+ locAPIAddGeofences(1, &geofence_id, &options, &data);
+}
+
+void GeofenceAPIClient::geofencePause(uint32_t geofence_id)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, geofence_id);
+ locAPIPauseGeofences(1, &geofence_id);
+}
+
+void GeofenceAPIClient::geofenceResume(uint32_t geofence_id, int32_t monitor_transitions)
+{
+ LOC_LOGD("%s]: (%d %d)", __FUNCTION__, geofence_id, monitor_transitions);
+ GeofenceBreachTypeMask mask = 0;
+ if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::ENTERED)
+ mask |= GEOFENCE_BREACH_ENTER_BIT;
+ if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::EXITED)
+ mask |= GEOFENCE_BREACH_EXIT_BIT;
+ locAPIResumeGeofences(1, &geofence_id, &mask);
+}
+
+void GeofenceAPIClient::geofenceRemove(uint32_t geofence_id)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, geofence_id);
+ locAPIRemoveGeofences(1, &geofence_id);
+}
+
+void GeofenceAPIClient::geofenceRemoveAll()
+{
+ LOC_LOGD("%s]", __FUNCTION__);
+ // TODO locAPIRemoveAllGeofences();
+}
+
+// callbacks
+void GeofenceAPIClient::onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification)
+{
+ LOC_LOGD("%s]: (%zu)", __FUNCTION__, geofenceBreachNotification.count);
+ if (mGnssGeofencingCbIface != nullptr) {
+ for (size_t i = 0; i < geofenceBreachNotification.count; i++) {
+ GnssLocation gnssLocation;
+ convertGnssLocation(geofenceBreachNotification.location, gnssLocation);
+
+ IGnssGeofenceCallback::GeofenceTransition transition;
+ if (geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER)
+ transition = IGnssGeofenceCallback::GeofenceTransition::ENTERED;
+ else if (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT)
+ transition = IGnssGeofenceCallback::GeofenceTransition::EXITED;
+ else {
+ // continue with other breach if transition is
+ // nether GPS_GEOFENCE_ENTERED nor GPS_GEOFENCE_EXITED
+ continue;
+ }
+
+ mGnssGeofencingCbIface->gnssGeofenceTransitionCb(
+ geofenceBreachNotification.ids[i], gnssLocation, transition,
+ static_cast<GnssUtcTime>(geofenceBreachNotification.timestamp));
+ }
+ }
+}
+
+void GeofenceAPIClient::onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, geofenceStatusNotification.available);
+ if (mGnssGeofencingCbIface != nullptr) {
+ IGnssGeofenceCallback::GeofenceAvailability status =
+ IGnssGeofenceCallback::GeofenceAvailability::UNAVAILABLE;
+ if (geofenceStatusNotification.available == GEOFENCE_STATUS_AVAILABILE_YES) {
+ status = IGnssGeofenceCallback::GeofenceAvailability::AVAILABLE;
+ }
+ GnssLocation gnssLocation;
+ memset(&gnssLocation, 0, sizeof(GnssLocation));
+ mGnssGeofencingCbIface->gnssGeofenceStatusCb(status, gnssLocation);
+ }
+}
+
+void GeofenceAPIClient::onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids)
+{
+ LOC_LOGD("%s]: (%zu)", __FUNCTION__, count);
+ if (mGnssGeofencingCbIface != nullptr) {
+ for (size_t i = 0; i < count; i++) {
+ IGnssGeofenceCallback::GeofenceStatus status =
+ IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC;
+ if (errors[i] == LOCATION_ERROR_SUCCESS)
+ status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS;
+ else if (errors[i] == LOCATION_ERROR_ID_EXISTS)
+ status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_EXISTS;
+ mGnssGeofencingCbIface->gnssGeofenceAddCb(ids[i], status);
+ }
+ }
+}
+
+void GeofenceAPIClient::onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids)
+{
+ LOC_LOGD("%s]: (%zu)", __FUNCTION__, count);
+ if (mGnssGeofencingCbIface != nullptr) {
+ for (size_t i = 0; i < count; i++) {
+ IGnssGeofenceCallback::GeofenceStatus status =
+ IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC;
+ if (errors[i] == LOCATION_ERROR_SUCCESS)
+ status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS;
+ else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN)
+ status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN;
+ mGnssGeofencingCbIface->gnssGeofenceRemoveCb(ids[i], status);
+ }
+ }
+}
+
+void GeofenceAPIClient::onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids)
+{
+ LOC_LOGD("%s]: (%zu)", __FUNCTION__, count);
+ if (mGnssGeofencingCbIface != nullptr) {
+ for (size_t i = 0; i < count; i++) {
+ IGnssGeofenceCallback::GeofenceStatus status =
+ IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC;
+ if (errors[i] == LOCATION_ERROR_SUCCESS)
+ status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS;
+ else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN)
+ status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN;
+ mGnssGeofencingCbIface->gnssGeofencePauseCb(ids[i], status);
+ }
+ }
+}
+
+void GeofenceAPIClient::onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids)
+{
+ LOC_LOGD("%s]: (%zu)", __FUNCTION__, count);
+ if (mGnssGeofencingCbIface != nullptr) {
+ for (size_t i = 0; i < count; i++) {
+ IGnssGeofenceCallback::GeofenceStatus status =
+ IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC;
+ if (errors[i] == LOCATION_ERROR_SUCCESS)
+ status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS;
+ else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN)
+ status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN;
+ mGnssGeofencingCbIface->gnssGeofenceResumeCb(ids[i], status);
+ }
+ }
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/location_api/GeofenceAPIClient.h b/msm8998/android/location_api/GeofenceAPIClient.h
new file mode 100644
index 0000000..f779bcb
--- /dev/null
+++ b/msm8998/android/location_api/GeofenceAPIClient.h
@@ -0,0 +1,76 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GEOFENCE_API_CLINET_H
+#define GEOFENCE_API_CLINET_H
+
+
+#include <android/hardware/gnss/1.0/IGnssGeofenceCallback.h>
+#include <LocationAPIClientBase.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::sp;
+
+class GeofenceAPIClient : public LocationAPIClientBase
+{
+public:
+ GeofenceAPIClient(const sp<IGnssGeofenceCallback>& callback);
+ virtual ~GeofenceAPIClient() = default;
+
+ void geofenceAdd(uint32_t geofence_id, double latitude, double longitude,
+ double radius_meters, int32_t last_transition, int32_t monitor_transitions,
+ uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms);
+ void geofencePause(uint32_t geofence_id);
+ void geofenceResume(uint32_t geofence_id, int32_t monitor_transitions);
+ void geofenceRemove(uint32_t geofence_id);
+ void geofenceRemoveAll();
+
+ // callbacks
+ void onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification) final;
+ void onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification) final;
+ void onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final;
+ void onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final;
+ void onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final;
+ void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final;
+
+private:
+ sp<IGnssGeofenceCallback> mGnssGeofencingCbIface;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+#endif // GEOFENCE_API_CLINET_H
diff --git a/msm8998/android/location_api/GnssAPIClient.cpp b/msm8998/android/location_api/GnssAPIClient.cpp
new file mode 100644
index 0000000..b4f0406
--- /dev/null
+++ b/msm8998/android/location_api/GnssAPIClient.cpp
@@ -0,0 +1,406 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_GnssAPIClient"
+
+#include <log_util.h>
+#include <loc_cfg.h>
+
+#include "LocationUtil.h"
+#include "GnssAPIClient.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out);
+
+GnssAPIClient::GnssAPIClient(const sp<IGnssCallback>& gpsCb,
+ const sp<IGnssNiCallback>& niCb) :
+ LocationAPIClientBase(),
+ mGnssCbIface(nullptr),
+ mGnssNiCbIface(nullptr),
+ mLocationCapabilitiesMask(0)
+{
+ LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
+
+ // set default LocationOptions.
+ memset(&mLocationOptions, 0, sizeof(LocationOptions));
+ mLocationOptions.size = sizeof(LocationOptions);
+ mLocationOptions.minInterval = 1000;
+ mLocationOptions.minDistance = 0;
+ mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE;
+
+ gnssUpdateCallbacks(gpsCb, niCb);
+}
+
+GnssAPIClient::~GnssAPIClient()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+}
+
+// for GpsInterface
+void GnssAPIClient::gnssUpdateCallbacks(const sp<IGnssCallback>& gpsCb,
+ const sp<IGnssNiCallback>& niCb)
+{
+ LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
+
+ mGnssCbIface = gpsCb;
+ mGnssNiCbIface = niCb;
+
+ LocationCallbacks locationCallbacks;
+ locationCallbacks.size = sizeof(LocationCallbacks);
+
+ locationCallbacks.trackingCb = nullptr;
+ if (mGnssCbIface != nullptr) {
+ locationCallbacks.trackingCb = [this](Location location) {
+ onTrackingCb(location);
+ };
+ }
+
+ locationCallbacks.batchingCb = nullptr;
+ locationCallbacks.geofenceBreachCb = nullptr;
+ locationCallbacks.geofenceStatusCb = nullptr;
+ locationCallbacks.gnssLocationInfoCb = nullptr;
+
+ locationCallbacks.gnssNiCb = nullptr;
+ if (mGnssNiCbIface != nullptr) {
+ locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotification) {
+ onGnssNiCb(id, gnssNiNotification);
+ };
+ }
+
+ locationCallbacks.gnssSvCb = nullptr;
+ if (mGnssCbIface != nullptr) {
+ locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) {
+ onGnssSvCb(gnssSvNotification);
+ };
+ }
+
+ locationCallbacks.gnssNmeaCb = nullptr;
+ if (mGnssCbIface != nullptr) {
+ locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) {
+ onGnssNmeaCb(gnssNmeaNotification);
+ };
+ }
+
+ locationCallbacks.gnssMeasurementsCb = nullptr;
+
+ locAPISetCallbacks(locationCallbacks);
+}
+
+bool GnssAPIClient::gnssStart()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ bool retVal = true;
+ locAPIStartTracking(mLocationOptions);
+ return retVal;
+}
+
+bool GnssAPIClient::gnssStop()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ bool retVal = true;
+ locAPIStopTracking();
+ return retVal;
+}
+
+void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags)
+{
+ LOC_LOGD("%s]: (%02hx)", __FUNCTION__, aidingDataFlags);
+ GnssAidingData data;
+ memset(&data, 0, sizeof (GnssAidingData));
+ data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS |
+ GNSS_AIDING_DATA_SV_TYPE_GLONASS |
+ GNSS_AIDING_DATA_SV_TYPE_QZSS |
+ GNSS_AIDING_DATA_SV_TYPE_BEIDOU |
+ GNSS_AIDING_DATA_SV_TYPE_GALILEO;
+
+ if (aidingDataFlags == IGnss::GnssAidingData::DELETE_ALL)
+ data.deleteAll = true;
+ else {
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_EPHEMERIS)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_EPHEMERIS;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_ALMANAC)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_ALMANAC;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_POSITION)
+ data.common.mask |= GNSS_AIDING_DATA_COMMON_POSITION;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_TIME)
+ data.common.mask |= GNSS_AIDING_DATA_COMMON_TIME;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_IONO)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_IONOSPHERE;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_UTC)
+ data.common.mask |= GNSS_AIDING_DATA_COMMON_UTC;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_HEALTH)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_HEALTH;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVDIR)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_DIRECTION;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVSTEER)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_STEER;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SADATA)
+ data.sv.svMask |= GNSS_AIDING_DATA_SV_SA_DATA;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_RTI)
+ data.common.mask |= GNSS_AIDING_DATA_COMMON_RTI;
+ if (aidingDataFlags & IGnss::GnssAidingData::DELETE_CELLDB_INFO)
+ data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB;
+ }
+ locAPIGnssDeleteAidingData(data);
+}
+
+bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode,
+ IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs,
+ uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs)
+{
+ LOC_LOGD("%s]: (%d %d %d %d %d)", __FUNCTION__,
+ (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters, preferredTimeMs);
+ bool retVal = true;
+ memset(&mLocationOptions, 0, sizeof(LocationOptions));
+ mLocationOptions.size = sizeof(LocationOptions);
+ mLocationOptions.minInterval = minIntervalMs;
+ mLocationOptions.minDistance = preferredAccuracyMeters;
+ if (mode == IGnss::GnssPositionMode::STANDALONE)
+ mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE;
+ else if (mode == IGnss::GnssPositionMode::MS_BASED)
+ mLocationOptions.mode = GNSS_SUPL_MODE_MSB;
+ else if (mode == IGnss::GnssPositionMode::MS_ASSISTED)
+ mLocationOptions.mode = GNSS_SUPL_MODE_MSA;
+ return retVal;
+}
+
+// for GpsNiInterface
+void GnssAPIClient::gnssNiRespond(int32_t notifId,
+ IGnssNiCallback::GnssUserResponseType userResponse)
+{
+ LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast<int>(userResponse));
+ GnssNiResponse data = GNSS_NI_RESPONSE_IGNORE;
+ if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT)
+ data = GNSS_NI_RESPONSE_ACCEPT;
+ else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY)
+ data = GNSS_NI_RESPONSE_DENY;
+ else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP)
+ data = GNSS_NI_RESPONSE_NO_RESPONSE;
+ locAPIGnssNiResponse(notifId, data);
+}
+
+// for GnssConfigurationInterface
+void GnssAPIClient::gnssConfigurationUpdate(const GnssConfig& gnssConfig)
+{
+ LOC_LOGD("%s]: (%02x)", __FUNCTION__, gnssConfig.flags);
+ locAPIGnssUpdateConfig(gnssConfig);
+}
+
+// callbacks
+void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
+{
+ LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask);
+ mLocationCapabilitiesMask = capabilitiesMask;
+ if (mGnssCbIface != nullptr) {
+ uint32_t data = 0;
+ if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) ||
+ (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) ||
+ (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT) ||
+ (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT))
+ data |= IGnssCallback::Capabilities::SCHEDULING;
+ if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT)
+ data |= IGnssCallback::Capabilities::GEOFENCING;
+ if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT)
+ data |= IGnssCallback::Capabilities::MEASUREMENTS;
+ if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT)
+ data |= IGnssCallback::Capabilities::MSB;
+ if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)
+ data |= IGnssCallback::Capabilities::MSA;
+ mGnssCbIface->gnssSetCapabilitesCb(data);
+ }
+ if (mGnssCbIface != nullptr) {
+ IGnssCallback::GnssSystemInfo gnssInfo;
+ gnssInfo.yearOfHw = 2015;
+ if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) {
+ gnssInfo.yearOfHw = 2017;
+ }
+ LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw);
+ mGnssCbIface->gnssSetSystemInfoCb(gnssInfo);
+ }
+}
+
+void GnssAPIClient::onTrackingCb(Location location)
+{
+ LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags);
+ if (mGnssCbIface != nullptr) {
+ GnssLocation gnssLocation;
+ convertGnssLocation(location, gnssLocation);
+ mGnssCbIface->gnssLocationCb(gnssLocation);
+ }
+}
+
+void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification)
+{
+ LOC_LOGD("%s]: (id: %d)", __FUNCTION__, id);
+
+ if (mGnssNiCbIface == nullptr) {
+ LOC_LOGE("%s]: mGnssNiCbIface is nullptr", __FUNCTION__);
+ return;
+ }
+
+ IGnssNiCallback::GnssNiNotification notificationGnss;
+
+ notificationGnss.notificationId = id;
+
+ if (gnssNiNotification.type == GNSS_NI_TYPE_VOICE)
+ notificationGnss.niType = IGnssNiCallback::GnssNiType::VOICE;
+ else if (gnssNiNotification.type == GNSS_NI_TYPE_SUPL)
+ notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_SUPL;
+ else if (gnssNiNotification.type == GNSS_NI_TYPE_CONTROL_PLANE)
+ notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_CTRL_PLANE;
+ // GNSS_NI_TYPE_EMERGENCY_SUPL not supported
+
+ if (gnssNiNotification.options == GNSS_NI_OPTIONS_NOTIFICATION)
+ notificationGnss.notifyFlags =
+ static_cast<uint32_t>(IGnssNiCallback::GnssNiNotifyFlags::NEED_NOTIFY);
+ else if (gnssNiNotification.options == GNSS_NI_OPTIONS_VERIFICATION)
+ notificationGnss.notifyFlags =
+ static_cast<uint32_t>(IGnssNiCallback::GnssNiNotifyFlags::NEED_VERIFY);
+ else if (gnssNiNotification.options == GNSS_NI_OPTIONS_PRIVACY_OVERRIDE)
+ notificationGnss.notifyFlags =
+ static_cast<uint32_t>(IGnssNiCallback::GnssNiNotifyFlags::PRIVACY_OVERRIDE);
+
+ notificationGnss.timeoutSec = gnssNiNotification.timeout;
+
+ if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_ACCEPT)
+ notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT;
+ else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_DENY)
+ notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY;
+ else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_NO_RESPONSE ||
+ gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_IGNORE)
+ notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP;
+
+ notificationGnss.requestorId = gnssNiNotification.requestor;
+
+ notificationGnss.notificationMessage = gnssNiNotification.message;
+
+ if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_NONE)
+ notificationGnss.requestorIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
+ else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
+ notificationGnss.requestorIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
+ else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
+ notificationGnss.requestorIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
+ else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
+ notificationGnss.requestorIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
+
+ if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_NONE)
+ notificationGnss.notificationIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
+ else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
+ notificationGnss.notificationIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
+ else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
+ notificationGnss.notificationIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
+ else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
+ notificationGnss.notificationIdEncoding =
+ IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
+
+ mGnssNiCbIface->niNotifyCb(notificationGnss);
+}
+
+void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification)
+{
+ LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssSvNotification.count);
+ if (mGnssCbIface != nullptr) {
+ IGnssCallback::GnssSvStatus svStatus;
+ convertGnssSvStatus(gnssSvNotification, svStatus);
+ mGnssCbIface->gnssSvStatusCb(svStatus);
+ }
+}
+
+void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
+{
+ if (mGnssCbIface != nullptr) {
+ android::hardware::hidl_string nmeaString;
+ nmeaString.setToExternal(gnssNmeaNotification.nmea, gnssNmeaNotification.length);
+ mGnssCbIface->gnssNmeaCb(static_cast<GnssUtcTime>(gnssNmeaNotification.timestamp),
+ nmeaString);
+ }
+}
+
+void GnssAPIClient::onStartTrackingCb(LocationError error)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
+ if (error == LOCATION_ERROR_SUCCESS && mGnssCbIface != nullptr) {
+ mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
+ mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
+ }
+}
+
+void GnssAPIClient::onStopTrackingCb(LocationError error)
+{
+ LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
+ if (error == LOCATION_ERROR_SUCCESS && mGnssCbIface != nullptr) {
+ mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END);
+ mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
+ }
+}
+
+static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out)
+{
+ memset(&out, 0, sizeof(IGnssCallback::GnssSvStatus));
+ out.numSvs = in.count;
+ if (out.numSvs > static_cast<uint32_t>(GnssMax::SVS_COUNT)) {
+ LOC_LOGW("%s]: Too many satellites %zd. Clamps to %d.",
+ __FUNCTION__, out.numSvs, GnssMax::SVS_COUNT);
+ out.numSvs = static_cast<uint32_t>(GnssMax::SVS_COUNT);
+ }
+ for (size_t i = 0; i < out.numSvs; i++) {
+ IGnssCallback::GnssSvInfo& info = out.gnssSvList[i];
+ info.svid = in.gnssSvs[i].svId;
+ convertGnssConstellationType(in.gnssSvs[i].type, info.constellation);
+ info.cN0Dbhz = in.gnssSvs[i].cN0Dbhz;
+ info.elevationDegrees = in.gnssSvs[i].elevation;
+ info.azimuthDegrees = in.gnssSvs[i].azimuth;
+ info.svFlag = static_cast<uint8_t>(IGnssCallback::GnssSvFlags::NONE);
+ if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT)
+ info.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA;
+ if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT)
+ info.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA;
+ if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)
+ info.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX;
+ }
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/location_api/GnssAPIClient.h b/msm8998/android/location_api/GnssAPIClient.h
new file mode 100644
index 0000000..1809c09
--- /dev/null
+++ b/msm8998/android/location_api/GnssAPIClient.h
@@ -0,0 +1,102 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GNSS_API_CLINET_H
+#define GNSS_API_CLINET_H
+
+
+#include <android/hardware/gnss/1.0/IGnss.h>
+#include <android/hardware/gnss/1.0/IGnssCallback.h>
+#include <android/hardware/gnss/1.0/IGnssNiCallback.h>
+#include <LocationAPIClientBase.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::sp;
+
+class GnssAPIClient : public LocationAPIClientBase
+{
+public:
+ GnssAPIClient(const sp<IGnssCallback>& gpsCb,
+ const sp<IGnssNiCallback>& niCb);
+ virtual ~GnssAPIClient();
+ GnssAPIClient(const GnssAPIClient&) = delete;
+ GnssAPIClient& operator=(const GnssAPIClient&) = delete;
+
+ // for GpsInterface
+ void gnssUpdateCallbacks(const sp<IGnssCallback>& gpsCb,
+ const sp<IGnssNiCallback>& niCb);
+ bool gnssStart();
+ bool gnssStop();
+ void gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags);
+ bool gnssSetPositionMode(IGnss::GnssPositionMode mode,
+ IGnss::GnssPositionRecurrence recurrence,
+ uint32_t minIntervalMs,
+ uint32_t preferredAccuracyMeters,
+ uint32_t preferredTimeMs);
+
+ // for GpsNiInterface
+ void gnssNiRespond(int32_t notifId, IGnssNiCallback::GnssUserResponseType userResponse);
+
+ // for GnssConfigurationInterface
+ void gnssConfigurationUpdate(const GnssConfig& gnssConfig);
+
+ inline LocationCapabilitiesMask gnssGetCapabilities() const {
+ return mLocationCapabilitiesMask;
+ }
+
+ // callbacks we are interested in
+ void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final;
+ void onTrackingCb(Location location) final;
+ void onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) final;
+ void onGnssSvCb(GnssSvNotification gnssSvNotification) final;
+ void onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) final;
+
+ void onStartTrackingCb(LocationError error) final;
+ void onStopTrackingCb(LocationError error) final;
+
+private:
+ sp<IGnssCallback> mGnssCbIface;
+ sp<IGnssNiCallback> mGnssNiCbIface;
+
+ LocationCapabilitiesMask mLocationCapabilitiesMask;
+
+ LocationOptions mLocationOptions;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+#endif // GNSS_API_CLINET_H
diff --git a/msm8998/android/location_api/GnssMeasurementAPIClient.cpp b/msm8998/android/location_api/GnssMeasurementAPIClient.cpp
new file mode 100644
index 0000000..3201625
--- /dev/null
+++ b/msm8998/android/location_api/GnssMeasurementAPIClient.cpp
@@ -0,0 +1,278 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_GnssMeasurementAPIClient"
+
+#include <log_util.h>
+#include <loc_cfg.h>
+
+#include "LocationUtil.h"
+#include "GnssMeasurementAPIClient.h"
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+static void convertGnssData(GnssMeasurementsNotification& in,
+ IGnssMeasurementCallback::GnssData& out);
+static void convertGnssMeasurement(GnssMeasurementsData& in,
+ IGnssMeasurementCallback::GnssMeasurement& out);
+static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out);
+
+GnssMeasurementAPIClient::GnssMeasurementAPIClient() :
+ mGnssMeasurementCbIface(nullptr),
+ mLocationCapabilitiesMask(0)
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ pthread_mutex_init(&mLock, nullptr);
+ pthread_cond_init (&mCond, nullptr);
+
+ // set default LocationOptions.
+ memset(&mLocationOptions, 0, sizeof(LocationOptions));
+ mLocationOptions.size = sizeof(LocationOptions);
+ mLocationOptions.minInterval = 1000;
+ mLocationOptions.minDistance = 0;
+ mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE;
+}
+
+GnssMeasurementAPIClient::~GnssMeasurementAPIClient()
+{
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ pthread_cond_destroy(&mCond);
+ pthread_mutex_destroy(&mLock);
+}
+
+// for GpsInterface
+Return<IGnssMeasurement::GnssMeasurementStatus>
+GnssMeasurementAPIClient::gnssMeasurementSetCallback(const sp<IGnssMeasurementCallback>& callback)
+{
+ LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback);
+
+ mGnssMeasurementCbIface = callback;
+
+ LocationCallbacks locationCallbacks;
+ locationCallbacks.size = sizeof(LocationCallbacks);
+
+ locationCallbacks.trackingCb = nullptr;
+ locationCallbacks.batchingCb = nullptr;
+ locationCallbacks.geofenceBreachCb = nullptr;
+ locationCallbacks.geofenceStatusCb = nullptr;
+ locationCallbacks.gnssLocationInfoCb = nullptr;
+ locationCallbacks.gnssNiCb = nullptr;
+ locationCallbacks.gnssSvCb = nullptr;
+ locationCallbacks.gnssNmeaCb = nullptr;
+
+ locationCallbacks.gnssMeasurementsCb = nullptr;
+ if (mGnssMeasurementCbIface != nullptr) {
+ locationCallbacks.gnssMeasurementsCb =
+ [this](GnssMeasurementsNotification gnssMeasurementsNotification) {
+ onGnssMeasurementsCb(gnssMeasurementsNotification);
+ };
+ }
+
+ locAPISetCallbacks(locationCallbacks);
+
+ while (!mLocationCapabilitiesMask) {
+ LOC_LOGD("%s]: wait for capabilities...", __FUNCTION__);
+ pthread_mutex_lock(&mLock);
+ pthread_cond_wait(&mCond, &mLock);
+ pthread_mutex_unlock(&mLock);
+ }
+ if (mLocationCapabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT)
+ mLocationOptions.mode = GNSS_SUPL_MODE_MSB;
+ else if (mLocationCapabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)
+ mLocationOptions.mode = GNSS_SUPL_MODE_MSA;
+ LOC_LOGD("%s]: start tracking session", __FUNCTION__);
+ locAPIStartTracking(mLocationOptions);
+
+ return IGnssMeasurement::GnssMeasurementStatus::SUCCESS;
+}
+
+// for GpsMeasurementInterface
+void GnssMeasurementAPIClient::gnssMeasurementClose() {
+ LOC_LOGD("%s]: ()", __FUNCTION__);
+ pthread_mutex_lock(&mLock);
+ mGnssMeasurementCbIface = nullptr;
+ pthread_mutex_unlock(&mLock);
+}
+
+// callbacks
+void GnssMeasurementAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
+{
+ LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask);
+ mLocationCapabilitiesMask = capabilitiesMask;
+ pthread_mutex_lock(&mLock);
+ pthread_cond_signal(&mCond);
+ pthread_mutex_unlock(&mLock);
+}
+
+void GnssMeasurementAPIClient::onGnssMeasurementsCb(
+ GnssMeasurementsNotification gnssMeasurementsNotification)
+{
+ LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssMeasurementsNotification.count);
+ // we don't need to lock the mutext
+ // if mGnssMeasurementCbIface is set to nullptr
+ if (mGnssMeasurementCbIface != nullptr) {
+ pthread_mutex_lock(&mLock);
+ if (mGnssMeasurementCbIface != nullptr) {
+ IGnssMeasurementCallback::GnssData gnssData;
+ convertGnssData(gnssMeasurementsNotification, gnssData);
+ mGnssMeasurementCbIface->GnssMeasurementCb(gnssData);
+ }
+ pthread_mutex_unlock(&mLock);
+ }
+}
+
+static void convertGnssMeasurement(GnssMeasurementsData& in,
+ IGnssMeasurementCallback::GnssMeasurement& out)
+{
+ memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssMeasurement));
+ if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT)
+ out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SNR;
+ if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT)
+ out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_FREQUENCY;
+ if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT)
+ out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_CYCLES;
+ if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT)
+ out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE;
+ if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT)
+ out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE_UNCERTAINTY;
+ out.svid = in.svId;
+ convertGnssConstellationType(in.svType, out.constellation);
+ out.timeOffsetNs = in.timeOffsetNs;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_CODE_LOCK;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BIT_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SUBFRAME_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_TOW_DECODED;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_MSEC_AMBIGUOUS;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SYMBOL_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_STRING_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_TOD_DECODED;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_BIT_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_SUBFRAME_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1BC_CODE_LOCK;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1C_2ND_CODE_LOCK;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1B_PAGE_SYNC;
+ if (in.stateMask & GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT)
+ out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SBAS_SYNC;
+ out.receivedSvTimeInNs = in.receivedSvTimeNs;
+ out.receivedSvTimeUncertaintyInNs = in.receivedSvTimeUncertaintyNs;
+ out.cN0DbHz = in.carrierToNoiseDbHz;
+ out.pseudorangeRateMps = in.pseudorangeRateMps;
+ out.pseudorangeRateUncertaintyMps = in.pseudorangeRateUncertaintyMps;
+ if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT)
+ out.accumulatedDeltaRangeState |=
+ IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_VALID;
+ if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT)
+ out.accumulatedDeltaRangeState |=
+ IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_RESET;
+ if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT)
+ out.accumulatedDeltaRangeState |=
+ IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_CYCLE_SLIP;
+ out.accumulatedDeltaRangeM = in.adrMeters;
+ out.accumulatedDeltaRangeUncertaintyM = in.adrUncertaintyMeters;
+ out.carrierFrequencyHz = in.carrierFrequencyHz;
+ out.carrierCycles = in.carrierCycles;
+ out.carrierPhase = in.carrierPhase;
+ out.carrierPhaseUncertainty = in.carrierPhaseUncertainty;
+ uint8_t indicator =
+ static_cast<uint8_t>(IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_UNKNOWN);
+ if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT)
+ indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_PRESENT;
+ if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT)
+ indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATIOR_NOT_PRESENT;
+ out.multipathIndicator =
+ static_cast<IGnssMeasurementCallback::GnssMultipathIndicator>(indicator);
+ out.snrDb = in.signalToNoiseRatioDb;
+}
+
+static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out)
+{
+ memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssClock));
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_LEAP_SECOND;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_TIME_UNCERTAINTY;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_FULL_BIAS;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS_UNCERTAINTY;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT;
+ if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT)
+ out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT_UNCERTAINTY;
+ out.leapSecond = in.leapSecond;
+ out.timeNs = in.timeNs;
+ out.timeUncertaintyNs = in.timeUncertaintyNs;
+ out.fullBiasNs = in.fullBiasNs;
+ out.biasNs = in.biasNs;
+ out.biasUncertaintyNs = in.biasUncertaintyNs;
+ out.driftNsps = in.driftNsps;
+ out.driftUncertaintyNsps = in.driftUncertaintyNsps;
+ out.hwClockDiscontinuityCount = in.hwClockDiscontinuityCount;
+}
+
+static void convertGnssData(GnssMeasurementsNotification& in,
+ IGnssMeasurementCallback::GnssData& out)
+{
+ out.measurementCount = in.count;
+ if (out.measurementCount > static_cast<uint32_t>(GnssMax::SVS_COUNT)) {
+ LOC_LOGW("%s]: Too many measurement %zd. Clamps to %d.",
+ __FUNCTION__, out.measurementCount, GnssMax::SVS_COUNT);
+ out.measurementCount = static_cast<uint32_t>(GnssMax::SVS_COUNT);
+ }
+ for (size_t i = 0; i < out.measurementCount; i++) {
+ convertGnssMeasurement(in.measurements[i], out.measurements[i]);
+ }
+ convertGnssClock(in.clock, out.clock);
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/android/location_api/GnssMeasurementAPIClient.h b/msm8998/android/location_api/GnssMeasurementAPIClient.h
new file mode 100644
index 0000000..02fe89a
--- /dev/null
+++ b/msm8998/android/location_api/GnssMeasurementAPIClient.h
@@ -0,0 +1,81 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GNSS_MEASUREMENT_API_CLINET_H
+#define GNSS_MEASUREMENT_API_CLINET_H
+
+
+#include <android/hardware/gnss/1.0/IGnssMeasurement.h>
+#include <android/hardware/gnss/1.0/IGnssMeasurementCallback.h>
+#include <LocationAPIClientBase.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::gnss::V1_0::IGnssMeasurement;
+using ::android::sp;
+
+class GnssMeasurementAPIClient : public LocationAPIClientBase
+{
+public:
+ GnssMeasurementAPIClient();
+ virtual ~GnssMeasurementAPIClient();
+ GnssMeasurementAPIClient(const GnssMeasurementAPIClient&) = delete;
+ GnssMeasurementAPIClient& operator=(const GnssMeasurementAPIClient&) = delete;
+
+ // for GpsMeasurementInterface
+ Return<IGnssMeasurement::GnssMeasurementStatus> gnssMeasurementSetCallback(
+ const sp<IGnssMeasurementCallback>& callback);
+ void gnssMeasurementClose();
+
+ // callbacks we are interested in
+ void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final;
+ void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final;
+
+private:
+ pthread_mutex_t mLock;
+ pthread_cond_t mCond;
+
+ sp<IGnssMeasurementCallback> mGnssMeasurementCbIface;
+
+ LocationCapabilitiesMask mLocationCapabilitiesMask;
+
+ LocationOptions mLocationOptions;
+};
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+#endif // GNSS_MEASUREMENT_API_CLINET_H
diff --git a/msm8998/android/location_api/LocationUtil.cpp b/msm8998/android/location_api/LocationUtil.cpp
new file mode 100644
index 0000000..dbafe5d
--- /dev/null
+++ b/msm8998/android/location_api/LocationUtil.cpp
@@ -0,0 +1,98 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <LocationUtil.h>
+
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
+
+void convertGnssLocation(Location& in, GnssLocation& out)
+{
+ memset(&out, 0, sizeof(GnssLocation));
+ if (in.flags & LOCATION_HAS_LAT_LONG_BIT)
+ out.gnssLocationFlags |= GnssLocationFlags::HAS_LAT_LONG;
+ if (in.flags & LOCATION_HAS_ALTITUDE_BIT)
+ out.gnssLocationFlags |= GnssLocationFlags::HAS_ALTITUDE;
+ if (in.flags & LOCATION_HAS_SPEED_BIT)
+ out.gnssLocationFlags |= GnssLocationFlags::HAS_SPEED;
+ if (in.flags & LOCATION_HAS_BEARING_BIT)
+ out.gnssLocationFlags |= GnssLocationFlags::HAS_BEARING;
+ if (in.flags & LOCATION_HAS_ACCURACY_BIT) {
+ out.gnssLocationFlags |= GnssLocationFlags::HAS_HORIZONTAL_ACCURACY;
+ //out.gnssLocationFlags |= GnssLocationFlags::HAS_VERTICAL_ACCURACY;
+ //out.gnssLocationFlags |= GnssLocationFlags::HAS_SPEED_ACCURACY;
+ //out.gnssLocationFlags |= GnssLocationFlags::HAS_BEARING_ACCURACY;
+ }
+ out.latitudeDegrees = in.latitude;
+ out.longitudeDegrees = in.longitude;
+ out.altitudeMeters = in.altitude;
+ out.speedMetersPerSec = in.speed;
+ out.bearingDegrees = in.bearing;
+ out.horizontalAccuracyMeters = in.accuracy;
+ //out.verticalAccuracyMeters = in.accuracy;
+ //out.speedAccuracyMetersPerSecond = in.accuracy;
+ //out.bearingAccuracyDegrees = in.accuracy;
+ out.timestamp = static_cast<GnssUtcTime>(in.timestamp);
+}
+
+void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out)
+{
+ switch(in) {
+ case GNSS_SV_TYPE_GPS:
+ out = GnssConstellationType::UNKNOWN;
+ break;
+ case GNSS_SV_TYPE_SBAS:
+ out = GnssConstellationType::SBAS;
+ break;
+ case GNSS_SV_TYPE_GLONASS:
+ out = GnssConstellationType::GLONASS;
+ break;
+ case GNSS_SV_TYPE_QZSS:
+ out = GnssConstellationType::QZSS;
+ break;
+ case GNSS_SV_TYPE_BEIDOU:
+ out = GnssConstellationType::BEIDOU;
+ break;
+ case GNSS_SV_TYPE_GALILEO:
+ out = GnssConstellationType::GALILEO;
+ break;
+ default:
+ out = GnssConstellationType::UNKNOWN;
+ break;
+ }
+}
+
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_log.h b/msm8998/android/location_api/LocationUtil.h
similarity index 72%
rename from msm8998/loc_api/libloc_api_50001/loc_eng_log.h
rename to msm8998/android/location_api/LocationUtil.h
index a68bd84..de098b1 100644
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_log.h
+++ b/msm8998/android/location_api/LocationUtil.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -27,18 +27,24 @@
*
*/
-#ifndef LOC_ENG_LOG_H
-#define LOC_ENG_LOG_H
+#ifndef LOCATION_UTIL_H
+#define LOCATION_UTIL_H
-#ifdef __cplusplus
-extern "C"
-{
-#endif
+#include <android/hardware/gnss/1.0/types.h>
+#include <LocationAPI.h>
-#include <ctype.h>
+namespace android {
+namespace hardware {
+namespace gnss {
+namespace V1_0 {
+namespace implementation {
-#ifdef __cplusplus
-}
-#endif
+void convertGnssLocation(Location& in, GnssLocation& out);
+void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out);
-#endif /* LOC_ENG_LOG_H */
+} // namespace implementation
+} // namespace V1_0
+} // namespace gnss
+} // namespace hardware
+} // namespace android
+#endif // LOCATION_UTIL_H
diff --git a/msm8998/android/service.cpp b/msm8998/android/service.cpp
new file mode 100644
index 0000000..bfa0d88
--- /dev/null
+++ b/msm8998/android/service.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ */
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_TAG "android.hardware.gnss@1.0-service-qti"
+
+#include <android/hardware/gnss/1.0/IGnss.h>
+#include <hidl/LegacySupport.h>
+
+using android::hardware::gnss::V1_0::IGnss;
+using android::hardware::defaultPassthroughServiceImplementation;
+
+int main() {
+ return defaultPassthroughServiceImplementation<IGnss>("gnss");
+}
diff --git a/msm8998/core/Android.mk b/msm8998/core/Android.mk
index 7fe2534..02056e3 100644
--- a/msm8998/core/Android.mk
+++ b/msm8998/core/Android.mk
@@ -6,7 +6,7 @@
include $(CLEAR_VARS)
LOCAL_MODULE := libloc_core
-LOCAL_MODULE_OWNER := qcom
+LOCAL_MODULE_OWNER := qti
LOCAL_MODULE_TAGS := optional
@@ -17,6 +17,7 @@
endif
LOCAL_SHARED_LIBRARIES := \
+ liblog \
libutils \
liblog \
libcutils \
@@ -37,8 +38,8 @@
LOCAL_C_INCLUDES:= \
$(TARGET_OUT_HEADERS)/gps.utils \
- $(TARGET_OUT_HEADERS)/libflp \
- $(TARGET_OUT_HEADERS)/libloc_pla
+ $(TARGET_OUT_HEADERS)/libloc_pla \
+ $(TARGET_OUT_HEADERS)/liblocation_api
LOCAL_COPY_HEADERS_TO:= libloc_core/
LOCAL_COPY_HEADERS:= \
diff --git a/msm8998/core/ContextBase.cpp b/msm8998/core/ContextBase.cpp
index 1ae8482..a9858e2 100644
--- a/msm8998/core/ContextBase.cpp
+++ b/msm8998/core/ContextBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014,2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -40,8 +40,116 @@
namespace loc_core {
-loc_gps_cfg_s_type ContextBase::mGps_conf {0};
-loc_sap_cfg_s_type ContextBase::mSap_conf {0};
+loc_gps_cfg_s_type ContextBase::mGps_conf {};
+loc_sap_cfg_s_type ContextBase::mSap_conf {};
+
+const loc_param_s_type ContextBase::mGps_conf_table[] =
+{
+ {"GPS_LOCK", &mGps_conf.GPS_LOCK, NULL, 'n'},
+ {"SUPL_VER", &mGps_conf.SUPL_VER, NULL, 'n'},
+ {"LPP_PROFILE", &mGps_conf.LPP_PROFILE, NULL, 'n'},
+ {"A_GLONASS_POS_PROTOCOL_SELECT", &mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'},
+ {"LPPE_CP_TECHNOLOGY", &mGps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'},
+ {"LPPE_UP_TECHNOLOGY", &mGps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'},
+ {"AGPS_CERT_WRITABLE_MASK", &mGps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'},
+ {"SUPL_MODE", &mGps_conf.SUPL_MODE, NULL, 'n'},
+ {"SUPL_ES", &mGps_conf.SUPL_ES, NULL, 'n'},
+ {"INTERMEDIATE_POS", &mGps_conf.INTERMEDIATE_POS, NULL, 'n'},
+ {"ACCURACY_THRES", &mGps_conf.ACCURACY_THRES, NULL, 'n'},
+ {"NMEA_PROVIDER", &mGps_conf.NMEA_PROVIDER, NULL, 'n'},
+ {"CAPABILITIES", &mGps_conf.CAPABILITIES, NULL, 'n'},
+ {"XTRA_VERSION_CHECK", &mGps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
+ {"XTRA_SERVER_1", &mGps_conf.XTRA_SERVER_1, NULL, 's'},
+ {"XTRA_SERVER_2", &mGps_conf.XTRA_SERVER_2, NULL, 's'},
+ {"XTRA_SERVER_3", &mGps_conf.XTRA_SERVER_3, NULL, 's'},
+ {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'},
+ {"AGPS_CONFIG_INJECT", &mGps_conf.AGPS_CONFIG_INJECT, NULL, 'n'},
+ {"EXTERNAL_DR_ENABLED", &mGps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'},
+};
+
+const loc_param_s_type ContextBase::mSap_conf_table[] =
+{
+ {"GYRO_BIAS_RANDOM_WALK", &mSap_conf.GYRO_BIAS_RANDOM_WALK, &mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
+ {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
+ {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
+ {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
+ {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
+ {"SENSOR_ACCEL_BATCHES_PER_SEC", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'},
+ {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
+ {"SENSOR_GYRO_BATCHES_PER_SEC", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'},
+ {"SENSOR_GYRO_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'},
+ {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'},
+ {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
+ {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'},
+ {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
+ {"SENSOR_CONTROL_MODE", &mSap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
+ {"SENSOR_USAGE", &mSap_conf.SENSOR_USAGE, NULL, 'n'},
+ {"SENSOR_ALGORITHM_CONFIG_MASK", &mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
+ {"SENSOR_PROVIDER", &mSap_conf.SENSOR_PROVIDER, NULL, 'n'}
+};
+
+void ContextBase::readConfig()
+{
+ /*Defaults for gps.conf*/
+ mGps_conf.INTERMEDIATE_POS = 0;
+ mGps_conf.ACCURACY_THRES = 0;
+ mGps_conf.NMEA_PROVIDER = 0;
+ mGps_conf.GPS_LOCK = 0;
+ mGps_conf.SUPL_VER = 0x10000;
+ mGps_conf.SUPL_MODE = 0x3;
+ mGps_conf.SUPL_ES = 0;
+ mGps_conf.CAPABILITIES = 0x7;
+ /* LTE Positioning Profile configuration is disable by default*/
+ mGps_conf.LPP_PROFILE = 0;
+ /*By default no positioning protocol is selected on A-GLONASS system*/
+ mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
+ /*XTRA version check is disabled by default*/
+ mGps_conf.XTRA_VERSION_CHECK=0;
+ /*Use emergency PDN by default*/
+ mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
+ /* By default no LPPe CP technology is enabled*/
+ mGps_conf.LPPE_CP_TECHNOLOGY = 0;
+ /* By default no LPPe UP technology is enabled*/
+ mGps_conf.LPPE_UP_TECHNOLOGY = 0;
+
+ /*Defaults for sap.conf*/
+ mSap_conf.GYRO_BIAS_RANDOM_WALK = 0;
+ mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
+ mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
+ mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
+ mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
+ mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
+ mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
+ mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
+ mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
+ mSap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
+ mSap_conf.SENSOR_USAGE = 0; /* Enabled */
+ mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
+ /* Values MUST be set by OEMs in configuration for sensor-assisted
+ navigation to work. There are NO default values */
+ mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
+ mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
+ mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
+ mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
+ mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
+ mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
+ mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
+ mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
+ mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
+ /* default provider is SSC */
+ mSap_conf.SENSOR_PROVIDER = 1;
+
+ /* None of the 10 slots for agps certificates are writable by default */
+ mGps_conf.AGPS_CERT_WRITABLE_MASK = 0;
+
+ /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */
+ mGps_conf.AGPS_CONFIG_INJECT = 1;
+
+ const char* GPS_CONF_FILE = "/etc/gps.conf";
+ const char* SAP_CONF_FILE = "/etc/sap.conf";
+ UTIL_READ_CONF(GPS_CONF_FILE, mGps_conf_table);
+ UTIL_READ_CONF(SAP_CONF_FILE, mSap_conf_table);
+}
uint32_t ContextBase::getCarrierCapabilities() {
#define carrierMSA (uint32_t)0x2
diff --git a/msm8998/core/ContextBase.h b/msm8998/core/ContextBase.h
index 87d2acf..83de999 100644
--- a/msm8998/core/ContextBase.h
+++ b/msm8998/core/ContextBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -34,6 +34,7 @@
#include <MsgTask.h>
#include <LocApiBase.h>
#include <LBSProxyBase.h>
+#include <loc_cfg.h>
#define MAX_XTRA_SERVER_URL_LENGTH 256
@@ -105,6 +106,8 @@
class ContextBase {
static LBSProxyBase* getLBSProxy(const char* libName);
LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask);
+ static const loc_param_s_type mGps_conf_table[];
+ static const loc_param_s_type mSap_conf_table[];
protected:
const LBSProxyBase* mLBSProxy;
const MsgTask* mMsgTask;
@@ -135,6 +138,7 @@
static loc_gps_cfg_s_type mGps_conf;
static loc_sap_cfg_s_type mSap_conf;
+ void readConfig();
static uint32_t getCarrierCapabilities();
};
diff --git a/msm8998/core/LocAdapterBase.cpp b/msm8998/core/LocAdapterBase.cpp
index 166fd91..27132b7 100644
--- a/msm8998/core/LocAdapterBase.cpp
+++ b/msm8998/core/LocAdapterBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -50,6 +50,16 @@
mLocApi->addAdapter(this);
}
+uint32_t LocAdapterBase::mSessionIdCounter(1);
+
+uint32_t LocAdapterBase::generateSessionId()
+{
+ if (++mSessionIdCounter == 0xFFFFFFFF)
+ mSessionIdCounter = 1;
+
+ return mSessionIdCounter;
+}
+
void LocAdapterBase::handleEngineUpEvent()
{
if (mLocAdapterProxyBase) {
@@ -65,32 +75,31 @@
}
void LocAdapterBase::
- reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask) {
- if (mLocAdapterProxyBase == NULL ||
- !mLocAdapterProxyBase->reportPosition(location,
- locationExtended,
- status,
- loc_technology_mask)) {
+ reportPositionEvent(const UlpLocation& location,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask,
+ bool fromUlp) {
+ if (mLocAdapterProxyBase != NULL) {
+ mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location,
+ (GpsLocationExtended&)locationExtended,
+ status,
+ loc_technology_mask);
+ } else {
DEFAULT_IMPL()
}
}
void LocAdapterBase::
- reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt)
+ reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp)
DEFAULT_IMPL()
void LocAdapterBase::
- reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
+ reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet)
DEFAULT_IMPL()
void LocAdapterBase::
- reportSvPolynomial(GnssSvPolynomial &svPolynomial)
+ reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial)
DEFAULT_IMPL()
void LocAdapterBase::
@@ -99,7 +108,7 @@
void LocAdapterBase::
- reportNmea(const char* nmea, int length)
+ reportNmeaEvent(const char* nmea, size_t length, bool fromUlp)
DEFAULT_IMPL()
bool LocAdapterBase::
@@ -140,11 +149,11 @@
DEFAULT_IMPL(false)
bool LocAdapterBase::
- requestNiNotify(LocGpsNiNotification ¬ify, const void* data)
+ requestNiNotifyEvent(GnssNiNotification ¬ify, const void* data)
DEFAULT_IMPL(false)
void LocAdapterBase::
- reportGnssMeasurementData(LocGnssData &gnssMeasurementData)
+ reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify)
DEFAULT_IMPL()
bool LocAdapterBase::
diff --git a/msm8998/core/LocAdapterBase.h b/msm8998/core/LocAdapterBase.h
index f3ec489..824a340 100644
--- a/msm8998/core/LocAdapterBase.h
+++ b/msm8998/core/LocAdapterBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -32,19 +32,39 @@
#include <gps_extended.h>
#include <UlpProxyBase.h>
#include <ContextBase.h>
+#include <LocationAPI.h>
+#include <map>
+
+typedef struct LocationSessionKey {
+ LocationAPI* client;
+ uint32_t id;
+ inline LocationSessionKey(LocationAPI* _client, uint32_t _id) :
+ client(_client), id(_id) {}
+} LocationSessionKey;
+inline bool operator <(LocationSessionKey const& left, LocationSessionKey const& right) {
+ return left.id < right.id || (left.id == right.id && left.client < right.client);
+}
+inline bool operator ==(LocationSessionKey const& left, LocationSessionKey const& right) {
+ return left.id == right.id && left.client == right.client;
+}
+inline bool operator !=(LocationSessionKey const& left, LocationSessionKey const& right) {
+ return left.id != right.id || left.client != right.client;
+}
+typedef std::map<LocationSessionKey, LocationOptions> LocationSessionMap;
namespace loc_core {
class LocAdapterProxyBase;
class LocAdapterBase {
+private:
+ static uint32_t mSessionIdCounter;
protected:
LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
ContextBase* mContext;
LocApiBase* mLocApi;
LocAdapterProxyBase* mLocAdapterProxyBase;
const MsgTask* mMsgTask;
-
inline LocAdapterBase(const MsgTask* msgTask) :
mEvtMask(0), mContext(NULL), mLocApi(NULL),
mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {}
@@ -70,11 +90,19 @@
}
inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
- loc_registration_mask_status isEnabled)
+ loc_registration_mask_status status)
{
- mEvtMask =
- isEnabled == LOC_REGISTRATION_MASK_ENABLED ? (mEvtMask|event):(mEvtMask&~event);
-
+ switch(status) {
+ case (LOC_REGISTRATION_MASK_ENABLED):
+ mEvtMask = mEvtMask | event;
+ break;
+ case (LOC_REGISTRATION_MASK_DISABLED):
+ mEvtMask = mEvtMask &~ event;
+ break;
+ case (LOC_REGISTRATION_MASK_SET):
+ mEvtMask = event;
+ break;
+ }
mLocApi->updateEvtMask();
}
@@ -82,33 +110,33 @@
return mLocApi->isFeatureSupported(featureVal);
}
+ uint32_t generateSessionId();
+
// This will be overridden by the individual adapters
// if necessary.
- inline virtual void setUlpProxy(UlpProxyBase* ulp) {
+ inline virtual void setUlpProxyCommand(UlpProxyBase* ulp) {
(void)ulp;
}
virtual void handleEngineUpEvent();
virtual void handleEngineDownEvent();
- inline virtual void setPositionModeInt(LocPosMode& posMode) {
+ inline virtual void setPositionModeCommand(LocPosMode& posMode) {
(void)posMode;
}
- virtual void startFixInt() {}
- virtual void stopFixInt() {}
- virtual void getZppInt() {}
- virtual void reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask);
- virtual void reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt);
- virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
- virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
+ virtual void startTrackingCommand() {}
+ virtual void stopTrackingCommand() {}
+ virtual void getZppCommand() {}
+ virtual void reportPositionEvent(const UlpLocation& location,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask,
+ bool fromUlp=false);
+ virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false);
+ virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false);
+ virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet);
+ virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);
virtual void reportStatus(LocGpsStatusValue status);
- virtual void reportNmea(const char* nmea, int length);
virtual bool reportXtraServer(const char* url1, const char* url2,
const char* url3, const int maxlength);
virtual bool requestXtraData();
@@ -119,11 +147,10 @@
virtual bool requestSuplES(int connHandle);
virtual bool reportDataCallOpened();
virtual bool reportDataCallClosed();
- virtual bool requestNiNotify(LocGpsNiNotification ¬ify,
- const void* data);
+ virtual bool requestNiNotifyEvent(GnssNiNotification ¬ify, const void* data);
inline virtual bool isInSession() { return false; }
ContextBase* getContext() const { return mContext; }
- virtual void reportGnssMeasurementData(LocGnssData &gnssMeasurementData);
+ virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify);
virtual bool reportWwanZppFix(LocGpsLocation &zppLoc);
};
diff --git a/msm8998/core/LocAdapterProxyBase.h b/msm8998/core/LocAdapterProxyBase.h
index 82cba6b..044f59b 100644
--- a/msm8998/core/LocAdapterProxyBase.h
+++ b/msm8998/core/LocAdapterProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -51,22 +51,25 @@
mLocAdapterBase->updateEvtMask(event,isEnabled);
}
+ inline uint32_t generateSessionId() {
+ return mLocAdapterBase->generateSessionId();
+ }
public:
inline ContextBase* getContext() const {
return mLocAdapterBase->getContext();
}
+
inline virtual void handleEngineUpEvent() {};
inline virtual void handleEngineDownEvent() {};
- inline virtual bool reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask) {
+ inline virtual void reportPositionEvent(UlpLocation &location,
+ GpsLocationExtended &locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask loc_technology_mask) {
(void)location;
(void)locationExtended;
(void)status;
(void)loc_technology_mask;
- return false;
}
};
diff --git a/msm8998/core/LocApiBase.cpp b/msm8998/core/LocApiBase.cpp
index 4cc8cb8..3bbbf8f 100644
--- a/msm8998/core/LocApiBase.cpp
+++ b/msm8998/core/LocApiBase.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -227,14 +227,13 @@
TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent());
}
-void LocApiBase::reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
+void LocApiBase::reportPosition(UlpLocation& location,
+ GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask)
{
// print the location info before delivering
- LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
+ LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n "
"altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n "
"timestamp: %lld\n rawDataSize: %d\n rawData: %p\n "
"Session status: %d\n Technology mask: %u\n "
@@ -251,11 +250,8 @@
locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask);
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
- mLocAdapters[i]->reportPosition(location,
- locationExtended,
- locationExt,
- status,
- loc_technology_mask)
+ mLocAdapters[i]->reportPositionEvent(location, locationExtended,
+ status, loc_technology_mask)
);
}
@@ -265,9 +261,7 @@
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportWwanZppFix(zppLoc));
}
-void LocApiBase::reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt)
+void LocApiBase::reportSv(GnssSvNotification& svNotify)
{
const char* constellationString[] = { "Unknown", "GPS", "SBAS", "GLONASS",
"QZSS", "BEIDOU", "GALILEO" };
@@ -276,27 +270,25 @@
LOC_LOGV("num sv: %d\n"
" sv: constellation svid cN0"
" elevation azimuth flags",
- svStatus.num_svs);
- for (int i = 0; i < svStatus.num_svs && i < LOC_GNSS_MAX_SVS; i++) {
- if (svStatus.gnss_sv_list[i].constellation >
+ svNotify.count);
+ for (int i = 0; i < svNotify.count && i < LOC_GNSS_MAX_SVS; i++) {
+ if (svNotify.gnssSvs[i].type >
sizeof(constellationString) / sizeof(constellationString[0]) - 1) {
- svStatus.gnss_sv_list[i].constellation = 0;
+ svNotify.gnssSvs[i].type = GNSS_SV_TYPE_UNKNOWN;
}
LOC_LOGV(" %03d: %*s %02d %f %f %f 0x%02X",
i,
13,
- constellationString[svStatus.gnss_sv_list[i].constellation],
- svStatus.gnss_sv_list[i].svid,
- svStatus.gnss_sv_list[i].c_n0_dbhz,
- svStatus.gnss_sv_list[i].elevation,
- svStatus.gnss_sv_list[i].azimuth,
- svStatus.gnss_sv_list[i].flags);
+ constellationString[svNotify.gnssSvs[i].type],
+ svNotify.gnssSvs[i].svId,
+ svNotify.gnssSvs[i].cN0Dbhz,
+ svNotify.gnssSvs[i].elevation,
+ svNotify.gnssSvs[i].azimuth,
+ svNotify.gnssSvs[i].gnssSvOptionsMask);
}
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
- mLocAdapters[i]->reportSv(svStatus,
- locationExtended,
- svExt)
+ mLocAdapters[i]->reportSvEvent(svNotify)
);
}
@@ -304,7 +296,7 @@
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
- mLocAdapters[i]->reportSvMeasurement(svMeasurementSet)
+ mLocAdapters[i]->reportSvMeasurementEvent(svMeasurementSet)
);
}
@@ -312,7 +304,7 @@
{
// loop through adapters, and deliver to all adapters.
TO_ALL_LOCADAPTERS(
- mLocAdapters[i]->reportSvPolynomial(svPolynomial)
+ mLocAdapters[i]->reportSvPolynomialEvent(svPolynomial)
);
}
@@ -325,7 +317,7 @@
void LocApiBase::reportNmea(const char* nmea, int length)
{
// loop through adapters, and deliver to all adapters.
- TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length));
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmeaEvent(nmea, length));
}
void LocApiBase::reportXtraServer(const char* url1, const char* url2,
@@ -384,10 +376,10 @@
TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed());
}
-void LocApiBase::requestNiNotify(LocGpsNiNotification ¬ify, const void* data)
+void LocApiBase::requestNiNotify(GnssNiNotification ¬ify, const void* data)
{
// loop through adapters, and deliver to the first handling adapter.
- TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data));
+ TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotifyEvent(notify, data));
}
void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList)
@@ -406,10 +398,10 @@
LocApiProxyBase* LocApiBase :: getLocApiProxy()
DEFAULT_IMPL(NULL)
-void LocApiBase::reportGnssMeasurementData(LocGnssData &gnssMeasurementData)
+void LocApiBase::reportGnssMeasurementData(GnssMeasurementsNotification& measurementsNotify)
{
// loop through adapters, and deliver to all adapters.
- TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData));
+ TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementDataEvent(measurementsNotify));
}
enum loc_api_adapter_err LocApiBase::
@@ -428,9 +420,9 @@
stopFix()
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- deleteAidingData(LocGpsAidingData f)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ deleteAidingData(const GnssAidingData& data)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
enum loc_api_adapter_err LocApiBase::
enableData(int enable)
@@ -469,31 +461,29 @@
setPositionMode(const LocPosMode& posMode)
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
+LocationError LocApiBase::
setServer(const char* url, int len)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- setServer(unsigned int ip, int port,
- LocServerType type)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setServer(unsigned int ip, int port, LocServerType type)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- informNiResponse(LocGpsUserResponseType userResponse,
- const void* passThroughData)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ informNiResponse(GnssNiResponse userResponse, const void* passThroughData)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- setSUPLVersion(uint32_t version)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setSUPLVersion(GnssConfigSuplVersion version)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
enum loc_api_adapter_err LocApiBase::
setNMEATypes (uint32_t typesMask)
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- setLPPConfig(uint32_t profile)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setLPPConfig(GnssConfigLppProfile profile)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
enum loc_api_adapter_err LocApiBase::
setSensorControlConfig(int sensorUsage,
@@ -526,13 +516,17 @@
int algorithmConfig)
DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- setAGLONASSProtocol(unsigned long aGlonassProtocol)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
-enum loc_api_adapter_err LocApiBase::
- setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP)
- DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+LocationError LocApiBase::
+ setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
enum loc_api_adapter_err LocApiBase::
getWwanZppFix()
@@ -573,9 +567,9 @@
releaseDataServiceClient()
DEFAULT_IMPL()
-int LocApiBase::
- setGpsLock(LOC_GPS_LOCK_MASK lock)
-DEFAULT_IMPL(-1)
+LocationError LocApiBase::
+ setGpsLock(GnssConfigGpsLock lock)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
void LocApiBase::
installAGpsCert(const LocDerEncodedCertificate* pData,
@@ -587,9 +581,9 @@
getGpsLock()
DEFAULT_IMPL(-1)
-enum loc_api_adapter_err LocApiBase::
- setXtraVersionCheck(enum xtra_version_check check)
-DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
+LocationError LocApiBase::
+ setXtraVersionCheck(uint32_t check)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
bool LocApiBase::
gnssConstellationConfig()
diff --git a/msm8998/core/LocApiBase.h b/msm8998/core/LocApiBase.h
index 9127a2e..86610e7 100644
--- a/msm8998/core/LocApiBase.h
+++ b/msm8998/core/LocApiBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, 2016 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -32,6 +32,7 @@
#include <stddef.h>
#include <ctype.h>
#include <gps_extended.h>
+#include <LocationAPI.h>
#include <MsgTask.h>
#include <platform_lib_log_util.h>
@@ -102,22 +103,18 @@
inline void sendMsg(const LocMsg* msg) const {
mMsgTask->sendMsg(msg);
}
-
void addAdapter(LocAdapterBase* adapter);
void removeAdapter(LocAdapterBase* adapter);
// upward calls
void handleEngineUpEvent();
void handleEngineDownEvent();
- void reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
+ void reportPosition(UlpLocation& location,
+ GpsLocationExtended& locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask =
LOC_POS_TECH_MASK_DEFAULT);
- void reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt);
+ void reportSv(GnssSvNotification& svNotify);
void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
void reportStatus(LocGpsStatusValue status);
@@ -132,9 +129,9 @@
void requestSuplES(int connHandle);
void reportDataCallOpened();
void reportDataCallClosed();
- void requestNiNotify(LocGpsNiNotification ¬ify, const void* data);
+ void requestNiNotify(GnssNiNotification ¬ify, const void* data);
void saveSupportedMsgList(uint64_t supportedMsgList);
- void reportGnssMeasurementData(LocGnssData &gnssMeasurementData);
+ void reportGnssMeasurementData(GnssMeasurementsNotification& measurementsNotify);
void saveSupportedFeatureList(uint8_t *featureList);
void reportWwanZppFix(LocGpsLocation &zppLoc);
@@ -148,8 +145,8 @@
startFix(const LocPosMode& posMode);
virtual enum loc_api_adapter_err
stopFix();
- virtual enum loc_api_adapter_err
- deleteAidingData(LocGpsAidingData f);
+ virtual LocationError
+ deleteAidingData(const GnssAidingData& data);
virtual enum loc_api_adapter_err
enableData(int enable);
virtual enum loc_api_adapter_err
@@ -168,19 +165,17 @@
atlCloseStatus(int handle, int is_succ);
virtual enum loc_api_adapter_err
setPositionMode(const LocPosMode& posMode);
- virtual enum loc_api_adapter_err
+ virtual LocationError
setServer(const char* url, int len);
- virtual enum loc_api_adapter_err
+ virtual LocationError
setServer(unsigned int ip, int port,
LocServerType type);
- virtual enum loc_api_adapter_err
- informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData);
- virtual enum loc_api_adapter_err
- setSUPLVersion(uint32_t version);
+ virtual LocationError
+ informNiResponse(GnssNiResponse userResponse, const void* passThroughData);
+ virtual LocationError setSUPLVersion(GnssConfigSuplVersion version);
virtual enum loc_api_adapter_err
setNMEATypes (uint32_t typesMask);
- virtual enum loc_api_adapter_err
- setLPPConfig(uint32_t profile);
+ virtual LocationError setLPPConfig(GnssConfigLppProfile profile);
virtual enum loc_api_adapter_err
setSensorControlConfig(int sensorUsage, int sensorProvider);
virtual enum loc_api_adapter_err
@@ -205,10 +200,10 @@
int gyroSamplesPerBatchHigh,
int gyroBatchesPerSecHigh,
int algorithmConfig);
- virtual enum loc_api_adapter_err
- setAGLONASSProtocol(unsigned long aGlonassProtocol);
- virtual enum loc_api_adapter_err
- setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP);
+ virtual LocationError
+ setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol);
+ virtual LocationError setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP);
+ virtual LocationError setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP);
virtual enum loc_api_adapter_err
getWwanZppFix();
virtual enum loc_api_adapter_err
@@ -238,15 +233,10 @@
return (messageChecker & mSupportedMsg) == messageChecker;
}
}
+
void updateEvtMask();
- /*Values for lock
- 1 = Do not lock any position sessions
- 2 = Lock MI position sessions
- 3 = Lock MT position sessions
- 4 = Lock all position sessions
- */
- virtual int setGpsLock(LOC_GPS_LOCK_MASK lock);
+ virtual LocationError setGpsLock(GnssConfigGpsLock lock);
/*
Returns
Current value of GPS Lock on success
@@ -254,8 +244,7 @@
*/
virtual int getGpsLock(void);
- virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check);
-
+ virtual LocationError setXtraVersionCheck(uint32_t check);
/*
Check if the modem support the service
*/
diff --git a/msm8998/core/LocDualContext.cpp b/msm8998/core/LocDualContext.cpp
index 74b2903..fd465e9 100644
--- a/msm8998/core/LocDualContext.cpp
+++ b/msm8998/core/LocDualContext.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -44,8 +44,7 @@
// excluded events for background clients
const LOC_API_ADAPTER_EVENT_MASK_T
LocDualContext::mBgExclMask =
- (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
- LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
+ (LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
LOC_API_ADAPTER_BIT_IOCTL_REPORT |
diff --git a/msm8998/core/LocDualContext.h b/msm8998/core/LocDualContext.h
index ce77a1a..2b1b4bb 100644
--- a/msm8998/core/LocDualContext.h
+++ b/msm8998/core/LocDualContext.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
diff --git a/msm8998/core/Makefile.am b/msm8998/core/Makefile.am
index 0a9d3e2..b3d833f 100644
--- a/msm8998/core/Makefile.am
+++ b/msm8998/core/Makefile.am
@@ -33,11 +33,11 @@
if USE_GLIB
libloc_core_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_core_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_core_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_core_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_core_la_CFLAGS = $(AM_CFLAGS)
-libloc_core_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
+libloc_core_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
libloc_core_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
diff --git a/msm8998/core/UlpProxyBase.h b/msm8998/core/UlpProxyBase.h
index d30e9cc..8863b66 100644
--- a/msm8998/core/UlpProxyBase.h
+++ b/msm8998/core/UlpProxyBase.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -30,7 +30,8 @@
#define ULP_PROXY_BASE_H
#include <gps_extended.h>
-#include "fused_location_extended.h"
+#include <LocationAPI.h>
+
namespace loc_core {
class LocAdapterBase;
@@ -51,24 +52,18 @@
return false;
}
- inline virtual bool reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
+ inline virtual bool reportPosition(const UlpLocation &location,
+ const GpsLocationExtended &locationExtended,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask) {
(void)location;
(void)locationExtended;
- (void)locationExt;
(void)status;
(void)loc_technology_mask;
return false;
}
- inline virtual bool reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt) {
- (void)svStatus;
- (void)locationExtended;
- (void)svExt;
+ inline virtual bool reportSv(const GnssSvNotification& svNotify) {
+ (void)svNotify;
return false;
}
inline virtual bool reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) {
@@ -94,17 +89,21 @@
(void)capabilities;
}
- inline virtual bool reportBatchingSession(FlpExtBatchOptions &options,
- bool active) {
-
- (void)options;
- (void)active;
- return false;
+ inline virtual bool reportBatchingSession(const LocationOptions& options, bool active)
+ {
+ (void)options;
+ (void)active;
+ return false;
}
- inline virtual bool reportPositions(const FlpExtLocation* locations,
- int32_t number_of_locations) {
- (void)locations;
- (void)number_of_locations;
+ inline virtual bool reportPositions(const UlpLocation* ulpLocations,
+ const GpsLocationExtended* extendedLocations,
+ const uint32_t* techMasks,
+ const size_t count)
+ {
+ (void)ulpLocations;
+ (void)extendedLocations;
+ (void)techMasks;
+ (void)count;
return false;
}
inline virtual bool reportDeleteAidingData(LocGpsAidingData aidingData)
diff --git a/msm8998/core/gps_extended.h b/msm8998/core/gps_extended.h
index 5255da1..dc6ad1e 100644
--- a/msm8998/core/gps_extended.h
+++ b/msm8998/core/gps_extended.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -29,19 +29,21 @@
#ifndef GPS_EXTENDED_H
#define GPS_EXTENDED_H
-#include <gps_extended_c.h>
/**
* @file
* @brief C++ declarations for GPS types
*/
+#include <gps_extended_c.h>
+#if defined(USE_GLIB) || defined(OFF_TARGET)
+#include <string.h>
+#endif
+
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
-#if defined(USE_GLIB) || defined(OFF_TARGET)
-#include <string.h>
-#endif
+
struct LocPosMode
{
diff --git a/msm8998/core/gps_extended_c.h b/msm8998/core/gps_extended_c.h
index c67e835..55fd03e 100644
--- a/msm8998/core/gps_extended_c.h
+++ b/msm8998/core/gps_extended_c.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2013-2015, 2016 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -34,6 +34,7 @@
#include <stdlib.h>
#include <string.h>
#include <loc_gps.h>
+#include <LocationAPI.h>
#include <time.h>
/**
@@ -86,20 +87,10 @@
#define LOC_AGPS_CERTIFICATE_MAX_LENGTH 2000
#define LOC_AGPS_CERTIFICATE_MAX_SLOTS 10
-typedef uint32_t LocPosTechMask;
-#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000)
-#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001)
-#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002)
-#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004)
-#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008)
-#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010)
-#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020)
-#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040)
-#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080)
-
enum loc_registration_mask_status {
LOC_REGISTRATION_MASK_ENABLED,
- LOC_REGISTRATION_MASK_DISABLED
+ LOC_REGISTRATION_MASK_DISABLED,
+ LOC_REGISTRATION_MASK_SET
};
typedef enum {
@@ -113,7 +104,6 @@
LocGpsLocation gpsLocation;
/* Provider indicator for HYBRID or GPS */
uint16_t position_source;
- LocPosTechMask tech_mask;
/*allows HAL to pass additional information related to the location */
int rawDataSize; /* in # of bytes */
void * rawData;
@@ -276,18 +266,6 @@
#define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH 0x0800
/** GpsLocationExtended has valid gnss sv used in position data */
#define GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA 0x1000
-/** GpsLocationExtended has valid navSolutionMask */
-#define GPS_LOCATION_EXTENDED_HAS_NAV_SOLUTION_MASK 0x2000
-
-typedef uint32_t LocNavSolutionMask;
-/* Bitmask to specify whether SBAS ionospheric correction is used */
-#define LOC_NAV_MASK_SBAS_CORRECTION_IONO ((LocNavSolutionMask)0x0001)
-/* Bitmask to specify whether SBAS fast correction is used */
-#define LOC_NAV_MASK_SBAS_CORRECTION_FAST ((LocNavSolutionMask)0x0002)
-/**< Bitmask to specify whether SBAS long-tem correction is used */
-#define LOC_NAV_MASK_SBAS_CORRECTION_LONG ((LocNavSolutionMask)0x0004)
-/**< Bitmask to specify whether SBAS integrity information is used */
-#define LOC_NAV_MASK_SBAS_INTEGRITY ((LocNavSolutionMask)0x0008)
/** GPS PRN Range */
#define GPS_SV_PRN_MIN 1
@@ -357,10 +335,6 @@
Gnss_ApTimeStampStructType timeStamp;
/** Gnss sv used in position data */
GnssSvUsedInPosition gnss_sv_used_ids;
- /** Nav solution mask to indicate sbas corrections */
- LocNavSolutionMask navSolutionMask;
- /** Position technology used in computing this fix */
- LocPosTechMask tech_mask;
} GpsLocationExtended;
enum loc_sess_status {
@@ -369,6 +343,17 @@
LOC_SESS_FAILURE
};
+typedef uint32_t LocPosTechMask;
+#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000)
+#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001)
+#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002)
+#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004)
+#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008)
+#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010)
+#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020)
+#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040)
+#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080)
+
// Nmea sentence types mask
typedef uint32_t NmeaSentenceTypesMask;
#define LOC_NMEA_MASK_GGA_V02 ((NmeaSentenceTypesMask)0x00000001) /**< Enable GGA type */
@@ -891,10 +876,8 @@
*/
uint64_t measurementStatus;
/**< Bitmask indicating SV measurement status.
- Valid bitmasks: \n
- If any MSB bit in 0xFFC0000000000000 DONT_USE is set, the measurement
- must not be used by the client.
- @MASK()
+ Valid bitmasks: \n
+ @MASK()
*/
uint16_t CNo;
/**< Carrier to Noise ratio \n
diff --git a/msm8998/core/loc_core_log.cpp b/msm8998/core/loc_core_log.cpp
index 620d1b0..b8addec 100644
--- a/msm8998/core/loc_core_log.cpp
+++ b/msm8998/core/loc_core_log.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
diff --git a/msm8998/core/loc_core_log.h b/msm8998/core/loc_core_log.h
index 4fe8d3f..2beb687 100644
--- a/msm8998/core/loc_core_log.h
+++ b/msm8998/core/loc_core_log.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 2016-2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -30,14 +30,14 @@
#ifndef LOC_CORE_LOG_H
#define LOC_CORE_LOG_H
+#include <ctype.h>
+#include <gps_extended.h>
+
#ifdef __cplusplus
extern "C"
{
#endif
-#include <ctype.h>
-#include <gps_extended.h>
-
const char* loc_get_gps_status_name(LocGpsStatusValue gps_status);
const char* loc_get_position_mode_name(LocGpsPositionMode mode);
const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur);
diff --git a/msm8998/core/loc_gps.h b/msm8998/core/loc_gps.h
index 2e495b8..cdb1af6 100644
--- a/msm8998/core/loc_gps.h
+++ b/msm8998/core/loc_gps.h
@@ -2187,7 +2187,7 @@
* Deliver GNSS configuration contents to HAL.
* Parameters:
* config_data - a pointer to a char array which holds what usually is expected from
- file(/vendor/etc/gps.conf), i.e., a sequence of UTF8 strings separated by '\n'.
+ file(/etc/gps.conf), i.e., a sequence of UTF8 strings separated by '\n'.
* length - total number of UTF8 characters in configuraiton data.
*
* IMPORTANT:
diff --git a/msm8998/etc/Android.mk b/msm8998/etc/Android.mk
index d9eb0e1..025d3f7 100644
--- a/msm8998/etc/Android.mk
+++ b/msm8998/etc/Android.mk
@@ -5,7 +5,7 @@
LOCAL_MODULE := gps.conf
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_CLASS := ETC
-LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR)/etc/
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/
LOCAL_SRC_FILES := gps.conf
include $(BUILD_PREBUILT)
diff --git a/msm8998/etc/gps.conf b/msm8998/etc/gps.conf
index 828cf68..895ebb5 100644
--- a/msm8998/etc/gps.conf
+++ b/msm8998/etc/gps.conf
@@ -127,77 +127,43 @@
# 0x2: WLAN AP Measurements for LPPe UP
LPPE_UP_TECHNOLOGY = 0
-##################################################
-# AGPS_CONFIG_INJECT
-##################################################
-# enable/disable injection of AGPS configurations:
-# SUPL_VER
-# SUPL_HOST
-# SUPL_PORT
-# C2K_HOST
-# C2K_PORT
-# LPP_PROFILE
-# A_GLONASS_POS_PROTOCOL_SELECT
-# 0: disable
-# 1: enable
-AGPS_CONFIG_INJECT = 1
-
-##################################################
-# GNSS settings for automotive use cases
-# Configurations in following section are
-# specific to automotive use cases, others
-# please do not change, keep the default values
-##################################################
-
# AP Coarse Timestamp Uncertainty
##################################################
# default : 10
-# AP time stamp uncertainty, until GNSS receiver
-# is able to acquire better timing information
+# or as per clock uncertainty of product
AP_TIMESTAMP_UNCERTAINTY = 10
-##################################################
-# QDR engine availability status
-##################################################
-# 0 : NO QDR (default)
-# 1 : QDR enabled
-# This settings enables QDR Configuration for
-# automotive use case, if enabled then
-# DR_AP_Service needs to be enabled in izat.conf
+#####################################
+# GNSS PPS settings
+#####################################
+#AP DR engine availability status
+# 0 : NO AP DR (default)
+# 1 : AP DR enabled
#EXTERNAL_DR_ENABLED = 0
#####################################
-# DR_SYNC Pulse Availability
+#DR_SYNC Pulse Availability
#####################################
# 0 : DR_SYNC pulse not available (default)
# 1 : DR_SYNC pulse available
-# This configuration enables the driver to make use
-# of PPS events generated by DR_SYNC pulse
-# Standard Linux PPS driver needs to be enabled
DR_SYNC_ENABLED = 0
#####################################
-# PPS Device name
+#PPS Device name
#####################################
PPS_DEVICENAME = /dev/pps0
#####################################
-# AP Clock Accuracy
+#AP Clock Accuracy
#####################################
-# Quality of APPS processor clock (in PPM).
-# Value specified is used for calculation of
-# APPS time stamp uncertainty
AP_CLOCK_PPM = 100
#####################################
-# MAX ms difference to detect missing pulse
+#MAX ms difference to detect missing pulse
#####################################
-# Specifies time threshold in ms to validate any missing PPS pulses
MISSING_PULSE_TIME_DELTA = 900
#####################################
-# Propagation time uncertainty
+#Propagation time uncertainty
#####################################
-# This settings enables time uncertainty propagation
-# logic incase of missing PPS pulse
PROPAGATION_TIME_UNCERTAINTY = 1
diff --git a/msm8998/gnss/Agps.cpp b/msm8998/gnss/Agps.cpp
new file mode 100644
index 0000000..aacd9da
--- /dev/null
+++ b/msm8998/gnss/Agps.cpp
@@ -0,0 +1,963 @@
+/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_TAG "LocSvc_Agps"
+
+#include <Agps.h>
+#include <platform_lib_includes.h>
+#include <ContextBase.h>
+#include <loc_timer.h>
+
+/* --------------------------------------------------------------------
+ * AGPS State Machine Methods
+ * -------------------------------------------------------------------*/
+void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
+
+ LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d",
+ this, event, mState);
+
+ switch (event){
+
+ case AGPS_EVENT_SUBSCRIBE:
+ processAgpsEventSubscribe();
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ processAgpsEventUnsubscribe();
+ break;
+
+ case AGPS_EVENT_GRANTED:
+ processAgpsEventGranted();
+ break;
+
+ case AGPS_EVENT_RELEASED:
+ processAgpsEventReleased();
+ break;
+
+ case AGPS_EVENT_DENIED:
+ processAgpsEventDenied();
+ break;
+
+ default:
+ LOC_LOGE("Invalid Loc Agps Event");
+ }
+}
+
+void AgpsStateMachine::processAgpsEventSubscribe(){
+
+ switch (mState){
+
+ case AGPS_STATE_RELEASED:
+ /* Add subscriber to list
+ * No notifications until we get RSRC_GRANTED */
+ addSubscriber(mCurrentSubscriber);
+
+ /* Send data request
+ * The if condition below is added so that if the data call setup
+ * fails for DS State Machine, we want to retry in released state.
+ * for Agps State Machine, sendRsrcRequest() will always return
+ * success. */
+ if(requestOrReleaseDataConn(true) == 0){
+ // If data request successful, move to pending state
+ transitionState(AGPS_STATE_PENDING);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ /* Already requested for data connection,
+ * do nothing until we get RSRC_GRANTED event;
+ * Just add this subscriber to the list, for notifications */
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* We already have the data connection setup,
+ * Notify current subscriber with GRANTED event,
+ * And add it to the subscriber list for further notifications. */
+ notifyEventToSubscriber(AGPS_EVENT_GRANTED, mCurrentSubscriber, false);
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ case AGPS_STATE_RELEASING:
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventUnsubscribe(){
+
+ switch (mState){
+
+ case AGPS_STATE_RELEASED:
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
+ break;
+
+ case AGPS_STATE_PENDING:
+ case AGPS_STATE_ACQUIRED:
+ /* If the subscriber wishes to wait for connection close,
+ * before being removed from list, move to inactive state
+ * and notify */
+ if(mCurrentSubscriber->mWaitForCloseComplete){
+ mCurrentSubscriber->mIsInactive = true;
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
+ }
+ else{
+ /* Notify only current subscriber and then delete it from
+ * subscriberList */
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
+ }
+
+ /* If no subscribers in list, release data connection */
+ if(mSubscriberList.empty()){
+ transitionState(AGPS_STATE_RELEASED);
+ requestOrReleaseDataConn(false);
+ }
+ /* Some subscribers in list, but all inactive;
+ * Release data connection */
+ else if(!anyActiveSubscribers()){
+ transitionState(AGPS_STATE_RELEASING);
+ requestOrReleaseDataConn(false);
+ }
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* If the subscriber wishes to wait for connection close,
+ * before being removed from list, move to inactive state
+ * and notify */
+ if(mCurrentSubscriber->mWaitForCloseComplete){
+ mCurrentSubscriber->mIsInactive = true;
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
+ }
+ else{
+ /* Notify only current subscriber and then delete it from
+ * subscriberList */
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
+ }
+
+ /* If no subscribers in list, just move the state.
+ * Request for releasing data connection should already have been
+ * sent */
+ if(mSubscriberList.empty()){
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventGranted(){
+
+ switch (mState){
+
+ case AGPS_STATE_RELEASED:
+ case AGPS_STATE_ACQUIRED:
+ case AGPS_STATE_RELEASING:
+ LOC_LOGE("Unexpected event GRANTED in state %d", mState);
+ break;
+
+ case AGPS_STATE_PENDING:
+ // Move to acquired state
+ transitionState(AGPS_STATE_ACQUIRED);
+ notifyAllSubscribers(
+ AGPS_EVENT_GRANTED, false,
+ AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventReleased(){
+
+ switch (mState){
+
+ case AGPS_STATE_RELEASED:
+ LOC_LOGE("Unexpected event RELEASED in state %d", mState);
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* Force release received */
+ LOC_LOGW("Force RELEASED event in ACQUIRED state");
+ transitionState(AGPS_STATE_RELEASED);
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* Notify all inactive subscribers about the event */
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
+
+ /* If we have active subscribers now, they must be waiting for
+ * data conn setup */
+ if(anyActiveSubscribers()){
+ transitionState(AGPS_STATE_PENDING);
+ requestOrReleaseDataConn(true);
+ }
+ /* No active subscribers, move to released state */
+ else{
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ /* NOOP */
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventDenied(){
+
+ switch (mState){
+
+ case AGPS_STATE_RELEASED:
+ LOC_LOGE("Unexpected event DENIED in state %d", mState);
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* NOOP */
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* Notify all inactive subscribers about the event */
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
+
+ /* If we have active subscribers now, they must be waiting for
+ * data conn setup */
+ if(anyActiveSubscribers()){
+ transitionState(AGPS_STATE_PENDING);
+ requestOrReleaseDataConn(true);
+ }
+ /* No active subscribers, move to released state */
+ else{
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ transitionState(AGPS_STATE_RELEASED);
+ notifyAllSubscribers(
+ AGPS_EVENT_DENIED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+/* Request or Release data connection
+ * bool request :
+ * true = Request data connection
+ * false = Release data connection */
+int AgpsStateMachine::requestOrReleaseDataConn(bool request){
+
+ AgpsFrameworkInterface::AGnssStatusIpV4 nifRequest;
+ memset(&nifRequest, 0, sizeof(nifRequest));
+
+ nifRequest.type = (AgpsFrameworkInterface::AGnssType)mAgpsType;
+
+ if(request){
+ LOC_LOGD("AGPS Data Conn Request");
+ nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
+ LOC_GPS_REQUEST_AGPS_DATA_CONN;
+ }
+ else{
+ LOC_LOGD("AGPS Data Conn Release");
+ nifRequest.status = (AgpsFrameworkInterface::AGnssStatusValue)
+ LOC_GPS_RELEASE_AGPS_DATA_CONN;
+ }
+
+ mAgpsManager->mFrameworkStatusV4Cb(nifRequest);
+ return 0;
+}
+
+void AgpsStateMachine::notifyAllSubscribers(
+ AgpsEvent event, bool deleteSubscriberPostNotify,
+ AgpsNotificationType notificationType){
+
+ LOC_LOGD("notifyAllSubscribers(): "
+ "SM %p, Event %d Delete %d Notification Type %d",
+ this, event, deleteSubscriberPostNotify, notificationType);
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ){
+
+ AgpsSubscriber* subscriber = *it;
+
+ if(notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
+ (notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS &&
+ subscriber->mIsInactive) ||
+ (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS &&
+ !subscriber->mIsInactive)) {
+
+ /* Deleting via this call would require another traversal
+ * through subscriber list, inefficient; hence pass in false*/
+ notifyEventToSubscriber(event, subscriber, false);
+
+ if(deleteSubscriberPostNotify){
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ } else{
+ it++;
+ }
+ } else{
+ it++;
+ }
+ }
+}
+
+void AgpsStateMachine::notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriberToNotify,
+ bool deleteSubscriberPostNotify) {
+
+ LOC_LOGD("notifyEventToSubscriber(): "
+ "SM %p, Event %d Subscriber %p Delete %d",
+ this, event, subscriberToNotify, deleteSubscriberPostNotify);
+
+ switch (event){
+
+ case AGPS_EVENT_GRANTED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 1, getAPN(),
+ getBearer(), mAgpsType);
+ break;
+
+ case AGPS_EVENT_DENIED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 0, getAPN(),
+ getBearer(), mAgpsType);
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ case AGPS_EVENT_RELEASED:
+ mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
+ break;
+
+ default:
+ LOC_LOGE("Invalid event %d", event);
+ }
+
+ /* Search this subscriber in list and delete */
+ if (deleteSubscriberPostNotify) {
+ deleteSubscriber(subscriberToNotify);
+ }
+}
+
+void AgpsStateMachine::transitionState(AgpsState newState){
+
+ LOC_LOGD("transitionState(): SM %p, old %d, new %d",
+ this, mState, newState);
+
+ mState = newState;
+
+ // notify state transitions to all subscribers ?
+}
+
+void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){
+
+ LOC_LOGD("addSubscriber(): SM %p, Subscriber %p",
+ this, subscriberToAdd);
+
+ // Check if subscriber is already present in the current list
+ // If not, then add
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for(; it != mSubscriberList.end(); it++){
+ AgpsSubscriber* subscriber = *it;
+ if(subscriber->equals(subscriberToAdd)){
+ LOC_LOGE("Subscriber already in list");
+ return;
+ }
+ }
+
+ AgpsSubscriber* cloned = subscriberToAdd->clone();
+ LOC_LOGD("addSubscriber(): cloned subscriber: %p", cloned);
+ mSubscriberList.push_back(cloned);
+}
+
+void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
+
+ LOC_LOGD("deleteSubscriber(): SM %p, Subscriber %p",
+ this, subscriberToDelete);
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ) {
+
+ AgpsSubscriber* subscriber = *it;
+ if(subscriber && subscriber->equals(subscriberToDelete)){
+
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ }else{
+ it++;
+ }
+ }
+}
+
+bool AgpsStateMachine::anyActiveSubscribers(){
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for(; it != mSubscriberList.end(); it++){
+ AgpsSubscriber* subscriber = *it;
+ if(!subscriber->mIsInactive){
+ return true;
+ }
+ }
+ return false;
+}
+
+void AgpsStateMachine::setAPN(char* apn, unsigned int len){
+
+ if (NULL != mAPN) {
+ delete mAPN;
+ }
+
+ if(apn == NULL || len <= 0){
+ LOC_LOGD("Invalid apn len (%d) or null apn", len);
+ mAPN = NULL;
+ mAPNLen = 0;
+ }
+
+ if (NULL != apn) {
+ mAPN = new char[len+1];
+ memcpy(mAPN, apn, len);
+ mAPN[len] = '\0';
+ mAPNLen = len;
+ }
+}
+
+AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for(; it != mSubscriberList.end(); it++){
+ AgpsSubscriber* subscriber = *it;
+ if(subscriber->mConnHandle == connHandle){
+ return subscriber;
+ }
+ }
+
+ /* Not found, return NULL */
+ return NULL;
+}
+
+AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for(; it != mSubscriberList.end(); it++){
+ AgpsSubscriber* subscriber = *it;
+ if(subscriber->mIsInactive == isInactive){
+ return subscriber;
+ }
+ }
+
+ /* Not found, return NULL */
+ return NULL;
+}
+
+void AgpsStateMachine::dropAllSubscribers(){
+
+ LOC_LOGD("dropAllSubscribers(): SM %p", this);
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ){
+ AgpsSubscriber* subscriber = *it;
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ }
+}
+
+/* --------------------------------------------------------------------
+ * DS State Machine Methods
+ * -------------------------------------------------------------------*/
+const int DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4;
+const int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500;
+
+/* Overridden method
+ * DS SM needs to handle one scenario differently */
+void DSStateMachine::processAgpsEvent(AgpsEvent event){
+
+ LOC_LOGD("DSStateMachine::processAgpsEvent() %d", event);
+
+ /* DS Client call setup APIs don't return failure/closure separately.
+ * Hence we receive RELEASED event in both cases.
+ * If we are in pending, we should consider RELEASED as DENIED */
+ if(event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING){
+
+ LOC_LOGD("Translating RELEASED to DENIED event");
+ event = AGPS_EVENT_DENIED;
+ }
+
+ /* Redirect process to base class */
+ AgpsStateMachine::processAgpsEvent(event);
+}
+
+/* Timer Callback
+ * For the retry timer started in case of DS Client call setup failure */
+void delay_callback(void *callbackData, int result)
+{
+ LOC_LOGD("delay_callback(): cbData %p", callbackData);
+
+ (void)result;
+
+ if(callbackData == NULL) {
+ LOC_LOGE("delay_callback(): NULL argument received !");
+ return;
+ }
+ DSStateMachine* dsStateMachine = (DSStateMachine *)callbackData;
+ dsStateMachine->retryCallback();
+}
+
+/* Invoked from Timer Callback
+ * For the retry timer started in case of DS Client call setup failure */
+void DSStateMachine :: retryCallback()
+{
+ LOC_LOGD("DSStateMachine::retryCallback()");
+
+ /* Request SUPL ES
+ * There must be at least one active subscriber in list */
+ AgpsSubscriber* subscriber = getFirstSubscriber(false);
+ if(subscriber == NULL) {
+
+ LOC_LOGE("No active subscriber for DS Client call setup");
+ return;
+ }
+
+ /* Send message to retry */
+ mAgpsManager->mSendMsgToAdapterQueueFn(
+ new AgpsMsgRequestATL(
+ mAgpsManager, subscriber->mConnHandle,
+ LOC_AGPS_TYPE_SUPL_ES));
+}
+
+/* Overridden method
+ * Request or Release data connection
+ * bool request :
+ * true = Request data connection
+ * false = Release data connection */
+int DSStateMachine::requestOrReleaseDataConn(bool request){
+
+ LOC_LOGD("DSStateMachine::requestOrReleaseDataConn(): "
+ "request %d", request);
+
+ /* Release data connection required ? */
+ if(!request && mAgpsManager->mDSClientStopDataCallFn){
+
+ mAgpsManager->mDSClientStopDataCallFn();
+ LOC_LOGD("DS Client release data call request sent !");
+ return 0;
+ }
+
+ /* Setup data connection request
+ * There must be at least one active subscriber in list */
+ AgpsSubscriber* subscriber = getFirstSubscriber(false);
+ if(subscriber == NULL) {
+
+ LOC_LOGE("No active subscriber for DS Client call setup");
+ return -1;
+ }
+
+ /* DS Client Fn registered ? */
+ if(!mAgpsManager->mDSClientOpenAndStartDataCallFn){
+
+ LOC_LOGE("DS Client start fn not registered, fallback to SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ return -1;
+ }
+
+ /* Setup the call */
+ int ret = mAgpsManager->mDSClientOpenAndStartDataCallFn();
+
+ /* Check if data call start failed */
+ switch (ret) {
+
+ case LOC_API_ADAPTER_ERR_ENGINE_BUSY:
+ LOC_LOGE("DS Client open call failed, err: %d", ret);
+ mRetries++;
+ if(mRetries > MAX_START_DATA_CALL_RETRIES) {
+
+ LOC_LOGE("DS Client call retries exhausted, "
+ "falling back to normal SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ }
+ /* Retry DS Client call setup after some delay */
+ else if(loc_timer_start(
+ DATA_CALL_RETRY_DELAY_MSEC, delay_callback, this)) {
+ LOC_LOGE("Error: Could not start delay thread\n");
+ return -1;
+ }
+ break;
+
+ case LOC_API_ADAPTER_ERR_UNSUPPORTED:
+ LOC_LOGE("No emergency profile found. Fall back to normal SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ break;
+
+ case LOC_API_ADAPTER_ERR_SUCCESS:
+ LOC_LOGD("Request to start data call sent");
+ break;
+
+ default:
+ LOC_LOGE("Unrecognized return value: %d", ret);
+ }
+
+ return ret;
+}
+
+void DSStateMachine::notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriberToNotify,
+ bool deleteSubscriberPostNotify) {
+
+ LOC_LOGD("DSStateMachine::notifyEventToSubscriber");
+
+ switch (event){
+
+ case AGPS_EVENT_GRANTED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 1, NULL,
+ AGPS_APN_BEARER_INVALID, LOC_AGPS_TYPE_SUPL_ES);
+ break;
+
+ case AGPS_EVENT_DENIED:
+ /* Now try with regular SUPL
+ * We need to send request via message queue */
+ mRetries = 0;
+ mAgpsManager->mSendMsgToAdapterQueueFn(
+ new AgpsMsgRequestATL(
+ mAgpsManager, subscriberToNotify->mConnHandle,
+ LOC_AGPS_TYPE_SUPL));
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
+ break;
+
+ case AGPS_EVENT_RELEASED:
+ mAgpsManager->mDSClientCloseDataCallFn();
+ break;
+
+ default:
+ LOC_LOGE("Invalid event %d", event);
+ }
+
+ /* Search this subscriber in list and delete */
+ if (deleteSubscriberPostNotify) {
+ deleteSubscriber(subscriberToNotify);
+ }
+}
+
+/* --------------------------------------------------------------------
+ * Loc AGPS Manager Methods
+ * -------------------------------------------------------------------*/
+
+/* CREATE AGPS STATE MACHINES
+ * Must be invoked in Msg Handler context */
+void AgpsManager::createAgpsStateMachines() {
+
+ LOC_LOGD("AgpsManager::createAgpsStateMachines");
+
+ bool agpsCapable =
+ ((loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) ||
+ (loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB));
+
+ if (NULL == mInternetNif) {
+ mInternetNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_WWAN_ANY);
+ LOC_LOGD("Internet NIF: %p", mInternetNif);
+ }
+ if (agpsCapable) {
+ if (NULL == mAgnssNif) {
+ mAgnssNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_SUPL);
+ LOC_LOGD("AGNSS NIF: %p", mAgnssNif);
+ }
+ if (NULL == mDsNif &&
+ loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
+
+ if(!mDSClientInitFn){
+
+ LOC_LOGE("DS Client Init Fn not registered !");
+ return;
+ }
+ if(mDSClientInitFn(false) != 0){
+
+ LOC_LOGE("Failed to init data service client");
+ return;
+ }
+ mDsNif = new DSStateMachine(this);
+ LOC_LOGD("DS NIF: %p", mDsNif);
+ }
+ }
+}
+
+AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) {
+
+ LOC_LOGD("AgpsManager::getAgpsStateMachine(): agpsType %d", agpsType);
+
+ switch (agpsType) {
+
+ case LOC_AGPS_TYPE_INVALID:
+ case LOC_AGPS_TYPE_SUPL:
+ if(mAgnssNif == NULL){
+ LOC_LOGE("NULL AGNSS NIF !");
+ }
+ return mAgnssNif;
+
+ case LOC_AGPS_TYPE_SUPL_ES:
+ if (loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+ if (mDsNif == NULL) {
+ createAgpsStateMachines();
+ }
+ return mDsNif;
+ } else {
+ return mAgnssNif;
+ }
+
+ default:
+ return mInternetNif;
+ }
+
+ LOC_LOGE("No SM found !");
+ return NULL;
+}
+
+void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::requestATL(): connHandle %d, agpsType %d",
+ connHandle, agpsType);
+
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+
+ if(sm == NULL){
+
+ LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType);
+ mAtlOpenStatusCb(
+ connHandle, 0, NULL, AGPS_APN_BEARER_INVALID, agpsType);
+ return;
+ }
+
+ /* Invoke AGPS SM processing */
+ AgpsSubscriber subscriber(connHandle);
+ sm->setCurrentSubscriber(&subscriber);
+
+ /* If DS State Machine, wait for close complete */
+ if(agpsType == LOC_AGPS_TYPE_SUPL_ES){
+ subscriber.mWaitForCloseComplete = true;
+ }
+
+ /* Send subscriber event */
+ sm->processAgpsEvent(AGPS_EVENT_SUBSCRIBE);
+}
+
+void AgpsManager::releaseATL(int connHandle){
+
+ LOC_LOGD("AgpsManager::releaseATL(): connHandle %d", connHandle);
+
+ /* First find the subscriber with specified handle.
+ * We need to search in all state machines. */
+ AgpsStateMachine* sm = NULL;
+ AgpsSubscriber* subscriber = NULL;
+
+ if (mAgnssNif &&
+ (subscriber = mAgnssNif->getSubscriber(connHandle)) != NULL) {
+ sm = mAgnssNif;
+ }
+ else if (mInternetNif &&
+ (subscriber = mInternetNif->getSubscriber(connHandle)) != NULL) {
+ sm = mInternetNif;
+ }
+ else if (mDsNif &&
+ (subscriber = mDsNif->getSubscriber(connHandle)) != NULL) {
+ sm = mDsNif;
+ }
+
+ if(sm == NULL){
+ LOC_LOGE("Subscriber with connHandle %d not found in any SM",
+ connHandle);
+ mAtlCloseStatusCb(connHandle, 0);
+ return;
+ }
+
+ /* Now send unsubscribe event */
+ sm->setCurrentSubscriber(subscriber);
+ sm->processAgpsEvent(AGPS_EVENT_UNSUBSCRIBE);
+}
+
+void AgpsManager::reportDataCallOpened(){
+
+ LOC_LOGD("AgpsManager::reportDataCallOpened");
+
+ if (mDsNif) {
+ mDsNif->processAgpsEvent(AGPS_EVENT_GRANTED);
+ }
+}
+
+void AgpsManager::reportDataCallClosed(){
+
+ LOC_LOGD("AgpsManager::reportDataCallClosed");
+
+ if (mDsNif) {
+ mDsNif->processAgpsEvent(AGPS_EVENT_RELEASED);
+ }
+}
+
+void AgpsManager::reportAtlOpenSuccess(
+ AGpsExtType agpsType, char* apnName, int apnLen,
+ LocApnIpType ipType){
+
+ LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): "
+ "AgpsType %d, APN [%s], Len %d, IPType %d",
+ agpsType, apnName, apnLen, ipType);
+
+ /* Find the state machine instance */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+
+ /* Convert LocApnIpType sent by framework to AGpsBearerType */
+ AGpsBearerType bearerType;
+ switch (ipType) {
+ case LOC_APN_IP_IPV4:
+ bearerType = AGPS_APN_BEARER_IPV4;
+ break;
+ case LOC_APN_IP_IPV6:
+ bearerType = AGPS_APN_BEARER_IPV6;
+ break;
+ case LOC_APN_IP_IPV4V6:
+ bearerType = AGPS_APN_BEARER_IPV4V6;
+ break;
+ default:
+ bearerType = AGPS_APN_BEARER_IPV4;
+ break;
+ }
+
+ /* Set bearer and apn info in state machine instance */
+ sm->setBearer(bearerType);
+ sm->setAPN(apnName, apnLen);
+
+ /* Send GRANTED event to state machine */
+ sm->processAgpsEvent(AGPS_EVENT_GRANTED);
+}
+
+void AgpsManager::reportAtlOpenFailed(AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::reportAtlOpenFailed(): AgpsType %d", agpsType);
+
+ /* Fetch SM and send DENIED event */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+ sm->processAgpsEvent(AGPS_EVENT_DENIED);
+}
+
+void AgpsManager::reportAtlClosed(AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::reportAtlClosed(): AgpsType %d", agpsType);
+
+ /* Fetch SM and send RELEASED event */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+ sm->processAgpsEvent(AGPS_EVENT_RELEASED);
+}
+
+void AgpsManager::handleModemSSR(){
+
+ LOC_LOGD("AgpsManager::handleModemSSR");
+
+ /* Drop subscribers from all state machines */
+ if (mAgnssNif){
+ mAgnssNif->dropAllSubscribers();
+ }
+ if (mInternetNif){
+ mInternetNif->dropAllSubscribers();
+ }
+ if(mDsNif){
+ mDsNif->dropAllSubscribers();
+ }
+
+ // reinitialize DS client in SSR mode
+ if(loc_core::ContextBase::mGps_conf.
+ USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL){
+
+ mDSClientStopDataCallFn();
+ mDSClientCloseDataCallFn();
+ mDSClientReleaseFn();
+
+ mDSClientInitFn(true);
+ }
+}
+
+AGpsBearerType AgpsUtils::ipTypeToBearerType(LocApnIpType ipType) {
+
+ switch (ipType) {
+
+ case LOC_APN_IP_IPV4:
+ return AGPS_APN_BEARER_IPV4;
+
+ case LOC_APN_IP_IPV6:
+ return AGPS_APN_BEARER_IPV6;
+
+ case LOC_APN_IP_IPV4V6:
+ return AGPS_APN_BEARER_IPV4V6;
+
+ default:
+ return AGPS_APN_BEARER_IPV4;
+ }
+}
+
+LocApnIpType AgpsUtils::bearerTypeToIpType(AGpsBearerType bearerType){
+
+ switch (bearerType) {
+
+ case AGPS_APN_BEARER_IPV4:
+ return LOC_APN_IP_IPV4;
+
+ case AGPS_APN_BEARER_IPV6:
+ return LOC_APN_IP_IPV6;
+
+ case AGPS_APN_BEARER_IPV4V6:
+ return LOC_APN_IP_IPV4V6;
+
+ default:
+ return LOC_APN_IP_IPV4;
+ }
+}
diff --git a/msm8998/gnss/Agps.h b/msm8998/gnss/Agps.h
new file mode 100644
index 0000000..1e95a42
--- /dev/null
+++ b/msm8998/gnss/Agps.h
@@ -0,0 +1,446 @@
+/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef AGPS_H
+#define AGPS_H
+
+#include <functional>
+#include <list>
+#include <MsgTask.h>
+#include <gps_extended_c.h>
+#include <platform_lib_log_util.h>
+
+/* ATL callback function pointers
+ * Passed in by Adapter to AgpsManager */
+typedef std::function<void(
+ int handle, int isSuccess, char* apn,
+ AGpsBearerType bearerType, AGpsExtType agpsType)> AgpsAtlOpenStatusCb;
+
+typedef std::function<void(int handle, int isSuccess)> AgpsAtlCloseStatusCb;
+
+/* DS Client control APIs
+ * Passed in by Adapter to AgpsManager */
+typedef std::function<int(bool isDueToSSR)> AgpsDSClientInitFn;
+typedef std::function<int()> AgpsDSClientOpenAndStartDataCallFn;
+typedef std::function<void()> AgpsDSClientStopDataCallFn;
+typedef std::function<void()> AgpsDSClientCloseDataCallFn;
+typedef std::function<void()> AgpsDSClientReleaseFn;
+
+/* Post message to adapter's message queue */
+typedef std::function<void(LocMsg* msg)> SendMsgToAdapterMsgQueueFn;
+
+/* AGPS States */
+typedef enum {
+ AGPS_STATE_INVALID = 0,
+ AGPS_STATE_RELEASED,
+ AGPS_STATE_PENDING,
+ AGPS_STATE_ACQUIRED,
+ AGPS_STATE_RELEASING
+} AgpsState;
+
+typedef enum {
+ AGPS_EVENT_INVALID = 0,
+ AGPS_EVENT_SUBSCRIBE,
+ AGPS_EVENT_UNSUBSCRIBE,
+ AGPS_EVENT_GRANTED,
+ AGPS_EVENT_RELEASED,
+ AGPS_EVENT_DENIED
+} AgpsEvent;
+
+/* Notification Types sent to subscribers */
+typedef enum {
+ AGPS_NOTIFICATION_TYPE_INVALID = 0,
+
+ /* Meant for all subscribers, either active or inactive */
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS,
+
+ /* Meant for only inactive subscribers */
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS,
+
+ /* Meant for only active subscribers */
+ AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS
+} AgpsNotificationType;
+
+/* Framework AGNSS interface
+ * This interface is defined in IAGnssCallback provided by
+ * Android Framework.
+ * Must be kept in sync with that interface. */
+namespace AgpsFrameworkInterface {
+
+ /** AGNSS type **/
+ enum AGnssType : uint8_t {
+ TYPE_SUPL = 1,
+ TYPE_C2K = 2
+ };
+
+ enum AGnssStatusValue : uint8_t {
+ /** GNSS requests data connection for AGNSS. */
+ REQUEST_AGNSS_DATA_CONN = 1,
+ /** GNSS releases the AGNSS data connection. */
+ RELEASE_AGNSS_DATA_CONN = 2,
+ /** AGNSS data connection initiated */
+ AGNSS_DATA_CONNECTED = 3,
+ /** AGNSS data connection completed */
+ AGNSS_DATA_CONN_DONE = 4,
+ /** AGNSS data connection failed */
+ AGNSS_DATA_CONN_FAILED = 5
+ };
+
+ /*
+ * Represents the status of AGNSS augmented to support IPv4.
+ */
+ struct AGnssStatusIpV4 {
+ AGnssType type;
+ AGnssStatusValue status;
+ /*
+ * 32-bit IPv4 address.
+ */
+ unsigned int ipV4Addr;
+ };
+
+ /*
+ * Represents the status of AGNSS augmented to support IPv6.
+ */
+ struct AGnssStatusIpV6 {
+ AGnssType type;
+ AGnssStatusValue status;
+ /*
+ * 128-bit IPv6 address.
+ */
+ unsigned char ipV6Addr[16];
+ };
+
+ /*
+ * Callback with AGNSS(IpV4) status information.
+ *
+ * @param status Will be of type AGnssStatusIpV4.
+ */
+ typedef void (*AgnssStatusIpV4Cb)(AGnssStatusIpV4 status);
+
+ /*
+ * Callback with AGNSS(IpV6) status information.
+ *
+ * @param status Will be of type AGnssStatusIpV6.
+ */
+ typedef void (*AgnssStatusIpV6Cb)(AGnssStatusIpV6 status);
+}
+
+/* Classes in this header */
+class AgpsSubscriber;
+class AgpsManager;
+class AgpsStateMachine;
+class DSStateMachine;
+
+
+/* SUBSCRIBER
+ * Each Subscriber instance corresponds to one AGPS request,
+ * received by the AGPS state machine */
+class AgpsSubscriber {
+
+public:
+ int mConnHandle;
+
+ /* Does this subscriber wait for data call close complete,
+ * before being notified ATL close ?
+ * While waiting for data call close, subscriber will be in
+ * inactive state. */
+ bool mWaitForCloseComplete;
+ bool mIsInactive;
+
+ inline AgpsSubscriber(int connHandle) :
+ mConnHandle(connHandle), mWaitForCloseComplete(false),
+ mIsInactive(false) {}
+ inline virtual ~AgpsSubscriber() {}
+
+ inline virtual bool equals(const AgpsSubscriber *s) const
+ { return (mConnHandle == s->mConnHandle); }
+
+ inline virtual AgpsSubscriber* clone()
+ { return new AgpsSubscriber(mConnHandle); }
+};
+
+/* AGPS STATE MACHINE */
+class AgpsStateMachine {
+protected:
+ /* AGPS Manager instance, from where this state machine is created */
+ AgpsManager* mAgpsManager;
+
+ /* List of all subscribers for this State Machine.
+ * Once a subscriber is notified for ATL open/close status,
+ * it is deleted */
+ std::list<AgpsSubscriber*> mSubscriberList;
+
+ /* Current subscriber, whose request this State Machine is
+ * currently processing */
+ AgpsSubscriber* mCurrentSubscriber;
+
+ /* Current state for this state machine */
+ AgpsState mState;
+
+private:
+ /* AGPS Type for this state machine
+ LOC_AGPS_TYPE_ANY 0
+ LOC_AGPS_TYPE_SUPL 1
+ LOC_AGPS_TYPE_WWAN_ANY 3
+ LOC_AGPS_TYPE_SUPL_ES 5 */
+ AGpsExtType mAgpsType;
+
+ /* APN and IP Type info for AGPS Call */
+ char* mAPN;
+ unsigned int mAPNLen;
+ AGpsBearerType mBearer;
+
+public:
+ /* CONSTRUCTOR */
+ AgpsStateMachine(AgpsManager* agpsManager, AGpsExtType agpsType):
+ mAgpsManager(agpsManager), mSubscriberList(),
+ mCurrentSubscriber(NULL), mState(AGPS_STATE_RELEASED),
+ mAgpsType(agpsType), mAPN(NULL), mAPNLen(0),
+ mBearer(AGPS_APN_BEARER_INVALID) {};
+
+ virtual ~AgpsStateMachine() { if(NULL != mAPN) delete[] mAPN; };
+
+ /* Getter/Setter methods */
+ void setAPN(char* apn, unsigned int len);
+ inline char* getAPN() const { return (char*)mAPN; }
+ inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; }
+ inline AGpsBearerType getBearer() const { return mBearer; }
+ inline AGpsExtType getType() const { return mAgpsType; }
+ inline void setCurrentSubscriber(AgpsSubscriber* subscriber)
+ { mCurrentSubscriber = subscriber; }
+
+ /* Fetch subscriber with specified handle */
+ AgpsSubscriber* getSubscriber(int connHandle);
+
+ /* Fetch first active or inactive subscriber in list
+ * isInactive = true : fetch first inactive subscriber
+ * isInactive = false : fetch first active subscriber */
+ AgpsSubscriber* getFirstSubscriber(bool isInactive);
+
+ /* Process LOC AGPS Event being passed in
+ * onRsrcEvent */
+ virtual void processAgpsEvent(AgpsEvent event);
+
+ /* Drop all subscribers, in case of Modem SSR */
+ void dropAllSubscribers();
+
+protected:
+ /* Remove the specified subscriber from list if present.
+ * Also delete the subscriber instance. */
+ void deleteSubscriber(AgpsSubscriber* subscriber);
+
+private:
+ /* Send call setup request to framework
+ * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)
+ * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */
+ virtual int requestOrReleaseDataConn(bool request);
+
+ /* Individual event processing methods */
+ void processAgpsEventSubscribe();
+ void processAgpsEventUnsubscribe();
+ void processAgpsEventGranted();
+ void processAgpsEventReleased();
+ void processAgpsEventDenied();
+
+ /* Clone the passed in subscriber and add to the subscriber list
+ * if not already present */
+ void addSubscriber(AgpsSubscriber* subscriber);
+
+ /* Notify subscribers about AGPS events */
+ void notifyAllSubscribers(
+ AgpsEvent event, bool deleteSubscriberPostNotify,
+ AgpsNotificationType notificationType);
+ virtual void notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriber,
+ bool deleteSubscriberPostNotify);
+
+ /* Do we have any subscribers in active state */
+ bool anyActiveSubscribers();
+
+ /* Transition state */
+ void transitionState(AgpsState newState);
+};
+
+/* DS STATE MACHINE */
+class DSStateMachine : public AgpsStateMachine {
+
+private:
+ static const int MAX_START_DATA_CALL_RETRIES;
+ static const int DATA_CALL_RETRY_DELAY_MSEC;
+
+ int mRetries;
+
+public:
+ /* CONSTRUCTOR */
+ DSStateMachine(AgpsManager* agpsManager):
+ AgpsStateMachine(agpsManager, LOC_AGPS_TYPE_SUPL_ES), mRetries(0) {}
+
+ /* Overridden method
+ * DS SM needs to handle one event differently */
+ void processAgpsEvent(AgpsEvent event);
+
+ /* Retry callback, used in case call failure */
+ void retryCallback();
+
+private:
+ /* Overridden method, different functionality for DS SM
+ * Send call setup request to framework
+ * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)
+ * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */
+ int requestOrReleaseDataConn(bool request);
+
+ /* Overridden method, different functionality for DS SM */
+ void notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriber,
+ bool deleteSubscriberPostNotify);
+};
+
+/* LOC AGPS MANAGER */
+class AgpsManager {
+
+ friend class AgpsStateMachine;
+ friend class DSStateMachine;
+
+public:
+ /* CONSTRUCTOR */
+ AgpsManager():
+ mFrameworkStatusV4Cb(NULL),
+ mAtlOpenStatusCb(), mAtlCloseStatusCb(),
+ mDSClientInitFn(), mDSClientOpenAndStartDataCallFn(),
+ mDSClientStopDataCallFn(), mDSClientCloseDataCallFn(), mDSClientReleaseFn(),
+ mSendMsgToAdapterQueueFn(),
+ mAgnssNif(NULL), mInternetNif(NULL), mDsNif(NULL) {}
+
+ /* Register callbacks */
+ void registerCallbacks(
+ AgpsFrameworkInterface::AgnssStatusIpV4Cb
+ frameworkStatusV4Cb,
+
+ AgpsAtlOpenStatusCb atlOpenStatusCb,
+ AgpsAtlCloseStatusCb atlCloseStatusCb,
+
+ AgpsDSClientInitFn dsClientInitFn,
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
+ AgpsDSClientReleaseFn dsClientReleaseFn,
+
+ SendMsgToAdapterMsgQueueFn sendMsgToAdapterQueueFn ){
+
+ mFrameworkStatusV4Cb = frameworkStatusV4Cb;
+
+ mAtlOpenStatusCb = atlOpenStatusCb;
+ mAtlCloseStatusCb = atlCloseStatusCb;
+
+ mDSClientInitFn = dsClientInitFn;
+ mDSClientOpenAndStartDataCallFn = dsClientOpenAndStartDataCallFn;
+ mDSClientStopDataCallFn = dsClientStopDataCallFn;
+ mDSClientCloseDataCallFn = dsClientCloseDataCallFn;
+ mDSClientReleaseFn = dsClientReleaseFn;
+
+ mSendMsgToAdapterQueueFn = sendMsgToAdapterQueueFn;
+ }
+
+ /* Create all AGPS state machines */
+ void createAgpsStateMachines();
+
+ /* Process incoming ATL requests */
+ void requestATL(int connHandle, AGpsExtType agpsType);
+ void releaseATL(int connHandle);
+
+ /* Process incoming DS Client data call events */
+ void reportDataCallOpened();
+ void reportDataCallClosed();
+
+ /* Process incoming framework data call events */
+ void reportAtlOpenSuccess(
+ AGpsExtType agpsType, char* apnName, int apnLen,
+ LocApnIpType ipType);
+ void reportAtlOpenFailed(AGpsExtType agpsType);
+ void reportAtlClosed(AGpsExtType agpsType);
+
+ /* Handle Modem SSR */
+ void handleModemSSR();
+
+protected:
+ AgpsFrameworkInterface::AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+
+ AgpsAtlOpenStatusCb mAtlOpenStatusCb;
+ AgpsAtlCloseStatusCb mAtlCloseStatusCb;
+
+ AgpsDSClientInitFn mDSClientInitFn;
+ AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn;
+ AgpsDSClientStopDataCallFn mDSClientStopDataCallFn;
+ AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn;
+ AgpsDSClientReleaseFn mDSClientReleaseFn;
+
+ SendMsgToAdapterMsgQueueFn mSendMsgToAdapterQueueFn;
+
+ AgpsStateMachine* mAgnssNif;
+ AgpsStateMachine* mInternetNif;
+ AgpsStateMachine* mDsNif;
+
+private:
+ /* Fetch state machine for handling request ATL call */
+ AgpsStateMachine* getAgpsStateMachine(AGpsExtType agpsType);
+};
+
+/* Request SUPL/INTERNET/SUPL_ES ATL
+ * This LocMsg is defined in this header since it has to be used from more
+ * than one place, other Agps LocMsg are restricted to GnssAdapter and
+ * declared inline */
+struct AgpsMsgRequestATL: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ int mConnHandle;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgRequestATL(AgpsManager* agpsManager, int connHandle,
+ AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle), mAgpsType(
+ agpsType) {
+
+ LOC_LOGV("AgpsMsgRequestATL");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgRequestATL::proc()");
+ mAgpsManager->requestATL(mConnHandle, mAgpsType);
+ }
+};
+
+namespace AgpsUtils {
+
+AGpsBearerType ipTypeToBearerType(LocApnIpType ipType);
+LocApnIpType bearerTypeToIpType(AGpsBearerType bearerType);
+
+}
+
+#endif /* AGPS_H */
diff --git a/msm8998/gnss/Android.mk b/msm8998/gnss/Android.mk
new file mode 100644
index 0000000..1f0a549
--- /dev/null
+++ b/msm8998/gnss/Android.mk
@@ -0,0 +1,44 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libgnss
+LOCAL_MODULE_OWNER := qti
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ libdl \
+ liblog \
+ libloc_core \
+ libgps.utils
+
+LOCAL_SRC_FILES += \
+ location_gnss.cpp \
+ GnssAdapter.cpp \
+ Agps.cpp
+
+LOCAL_CFLAGS += \
+ -fno-short-enums \
+
+ifeq ($(TARGET_BUILD_VARIANT),user)
+ LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
+endif
+
+LOCAL_C_INCLUDES:= \
+ $(TARGET_OUT_HEADERS)/gps.utils \
+ $(TARGET_OUT_HEADERS)/libloc_core \
+ $(TARGET_OUT_HEADERS)/libloc_pla \
+ $(TARGET_OUT_HEADERS)/liblocation_api
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/msm8998/gnss/GnssAdapter.cpp b/msm8998/gnss/GnssAdapter.cpp
new file mode 100644
index 0000000..ab9b80c
--- /dev/null
+++ b/msm8998/gnss/GnssAdapter.cpp
@@ -0,0 +1,3200 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#define LOG_TAG "LocSvc_GnssAdapter"
+
+#include <sys/stat.h>
+#include <errno.h>
+#include <ctype.h>
+#include <cutils/properties.h>
+#include <math.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <GnssAdapter.h>
+#include <string>
+#include <loc_log.h>
+#include <Agps.h>
+
+using namespace loc_core;
+
+GnssAdapter::GnssAdapter() :
+ LocAdapterBase(0,
+ LocDualContext::getLocFgContext(NULL,
+ NULL,
+ LocDualContext::mLocationHalName,
+ false)),
+ mUlpProxy(new UlpProxyBase()),
+ mSuplMode(GNSS_SUPL_MODE_STANDALONE),
+ mUlpPositionMode(),
+ mGnssSvIdUsedInPosition(),
+ mGnssSvIdUsedInPosAvail(false),
+ mControlCallbacks(),
+ mPowerVoteId(0),
+ mNiData(),
+ mAgpsManager()
+{
+ LOC_LOGD("%s]: Constructor %p", __func__, this);
+ mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID;
+ readConfigCommand();
+ setConfigCommand();
+
+}
+
+inline
+GnssAdapter::~GnssAdapter()
+{
+ LOC_LOGD("%s]: Destructor", __func__);
+ delete mUlpProxy;
+}
+
+void
+GnssAdapter::setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks)
+{
+ struct MsgSetControlCallbacks : public LocMsg {
+ GnssAdapter& mAdapter;
+ const LocationControlCallbacks mControlCallbacks;
+ inline MsgSetControlCallbacks(GnssAdapter& adapter,
+ LocationControlCallbacks& controlCallbacks) :
+ LocMsg(),
+ mAdapter(adapter),
+ mControlCallbacks(controlCallbacks) {}
+ inline virtual void proc() const {
+ mAdapter.setControlCallbacks(mControlCallbacks);
+ }
+ };
+
+ sendMsg(new MsgSetControlCallbacks(*this, controlCallbacks));
+}
+
+void
+GnssAdapter::convertOptions(LocPosMode& out, const LocationOptions& options)
+{
+ LocPosMode locPosMode = {};
+ switch (options.mode) {
+ case GNSS_SUPL_MODE_MSB:
+ out.mode = LOC_POSITION_MODE_MS_BASED;
+ break;
+ case GNSS_SUPL_MODE_MSA:
+ out.mode = LOC_POSITION_MODE_MS_ASSISTED;
+ break;
+ default:
+ out.mode = LOC_POSITION_MODE_STANDALONE;
+ break;
+ }
+ out.share_position = true;
+ out.min_interval = options.minInterval;
+}
+
+void
+GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
+ const LocPosTechMask techMask)
+{
+ out.size = sizeof(Location);
+ if (LOC_GPS_LOCATION_HAS_LAT_LONG & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_LAT_LONG_BIT;
+ out.latitude = locGpsLocation.latitude;
+ out.longitude = locGpsLocation.longitude;
+ }
+ if (LOC_GPS_LOCATION_HAS_ALTITUDE & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_ALTITUDE_BIT;
+ out.altitude = locGpsLocation.altitude;
+ }
+ if (LOC_GPS_LOCATION_HAS_SPEED & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_SPEED_BIT;
+ out.speed = locGpsLocation.speed;
+ }
+ if (LOC_GPS_LOCATION_HAS_BEARING & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_BEARING_BIT;
+ out.bearing = locGpsLocation.bearing;
+ }
+ if (LOC_GPS_LOCATION_HAS_ACCURACY & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_ACCURACY_BIT;
+ out.accuracy = locGpsLocation.accuracy;
+ }
+ out.timestamp = locGpsLocation.timestamp;
+ if (LOC_POS_TECH_MASK_SATELLITE & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_GNSS_BIT;
+ }
+ if (LOC_POS_TECH_MASK_CELLID & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_CELL_BIT;
+ }
+ if (LOC_POS_TECH_MASK_WIFI & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_WIFI_BIT;
+ }
+ if (LOC_POS_TECH_MASK_SENSORS & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_SENSORS_BIT;
+ }
+}
+
+void
+GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out,
+ const GpsLocationExtended& locationExtended)
+{
+ out.size = sizeof(GnssLocationInfoNotification);
+ if (GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT;
+ out.altitudeMeanSeaLevel = locationExtended.altitudeMeanSeaLevel;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_DOP_BIT;
+ out.pdop = locationExtended.pdop;
+ out.hdop = locationExtended.hdop;
+ out.vdop = locationExtended.vdop;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT;
+ out.magneticDeviation = locationExtended.magneticDeviation;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_VERT_UNC & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_VER_ACCURACY_BIT;
+ out.verAccuracy = locationExtended.vert_unc;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_SPEED_UNC & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_SPEED_ACCURACY_BIT;
+ out.speedAccuracy = locationExtended.speed_unc;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_BEARING_UNC & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_BEARING_ACCURACY_BIT;
+ out.bearingAccuracy = locationExtended.bearing_unc;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT;
+ switch (locationExtended.horizontal_reliability) {
+ case LOC_RELIABILITY_VERY_LOW:
+ out.horReliability = LOCATION_RELIABILITY_VERY_LOW;
+ break;
+ case LOC_RELIABILITY_LOW:
+ out.horReliability = LOCATION_RELIABILITY_LOW;
+ break;
+ case LOC_RELIABILITY_MEDIUM:
+ out.horReliability = LOCATION_RELIABILITY_MEDIUM;
+ break;
+ case LOC_RELIABILITY_HIGH:
+ out.horReliability = LOCATION_RELIABILITY_HIGH;
+ break;
+ default:
+ out.horReliability = LOCATION_RELIABILITY_NOT_SET;
+ break;
+ }
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_VER_RELIABILITY_BIT;
+ switch (locationExtended.vertical_reliability) {
+ case LOC_RELIABILITY_VERY_LOW:
+ out.verReliability = LOCATION_RELIABILITY_VERY_LOW;
+ break;
+ case LOC_RELIABILITY_LOW:
+ out.verReliability = LOCATION_RELIABILITY_LOW;
+ break;
+ case LOC_RELIABILITY_MEDIUM:
+ out.verReliability = LOCATION_RELIABILITY_MEDIUM;
+ break;
+ case LOC_RELIABILITY_HIGH:
+ out.verReliability = LOCATION_RELIABILITY_HIGH;
+ break;
+ default:
+ out.verReliability = LOCATION_RELIABILITY_NOT_SET;
+ break;
+ }
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT;
+ out.horUncEllipseSemiMajor = locationExtended.horUncEllipseSemiMajor;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT;
+ out.horUncEllipseSemiMinor = locationExtended.horUncEllipseSemiMinor;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT;
+ out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertGpsLock(const GnssConfigGpsLock gpsLock)
+{
+ switch (gpsLock) {
+ case GNSS_CONFIG_GPS_LOCK_MO:
+ return 1;
+ case GNSS_CONFIG_GPS_LOCK_NI:
+ return 2;
+ case GNSS_CONFIG_GPS_LOCK_MO_AND_NI:
+ return 3;
+ case GNSS_CONFIG_GPS_LOCK_NONE:
+ default:
+ return 0;
+ }
+}
+
+inline GnssConfigGpsLock
+GnssAdapter::convertGpsLock(const uint32_t gpsLock)
+{
+ switch (gpsLock) {
+ case 1:
+ return GNSS_CONFIG_GPS_LOCK_MO;
+ case 2:
+ return GNSS_CONFIG_GPS_LOCK_NI;
+ case 3:
+ return GNSS_CONFIG_GPS_LOCK_MO_AND_NI;
+ case 0:
+ default:
+ return GNSS_CONFIG_GPS_LOCK_NONE;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertSuplVersion(const GnssConfigSuplVersion suplVersion)
+{
+ switch (suplVersion) {
+ case GNSS_CONFIG_SUPL_VERSION_2_0_0:
+ return 0x00020000;
+ case GNSS_CONFIG_SUPL_VERSION_2_0_2:
+ return 0x00020002;
+ case GNSS_CONFIG_SUPL_VERSION_1_0_0:
+ default:
+ return 0x00010000;
+ }
+}
+
+inline GnssConfigSuplVersion
+GnssAdapter::convertSuplVersion(const uint32_t suplVersion)
+{
+ switch (suplVersion) {
+ case 0x00020000:
+ return GNSS_CONFIG_SUPL_VERSION_2_0_0;
+ case 0x00020002:
+ return GNSS_CONFIG_SUPL_VERSION_2_0_2;
+ case 0x00010000:
+ default:
+ return GNSS_CONFIG_SUPL_VERSION_1_0_0;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile)
+{
+ switch (lppProfile) {
+ case GNSS_CONFIG_LPP_PROFILE_USER_PLANE:
+ return 1;
+ case GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE:
+ return 2;
+ case GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE:
+ return 3;
+ case GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE:
+ default:
+ return 0;
+ }
+}
+
+inline GnssConfigLppProfile
+GnssAdapter::convertLppProfile(const uint32_t lppProfile)
+{
+ switch (lppProfile) {
+ case 1:
+ return GNSS_CONFIG_LPP_PROFILE_USER_PLANE;
+ case 2:
+ return GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE;
+ case 3:
+ return GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE;
+ case 0:
+ default:
+ return GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE;
+ }
+}
+
+uint32_t
+GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT & lppeControlPlaneMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) {
+ mask |= (1<<1);
+ }
+ return mask;
+}
+
+GnssConfigLppeControlPlaneMask
+GnssAdapter::convertLppeCp(const uint32_t lppeControlPlaneMask)
+{
+ GnssConfigLppeControlPlaneMask mask = 0;
+ if ((1<<0) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT;
+ }
+ if ((1<<1) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT;
+ }
+ return mask;
+}
+
+
+uint32_t
+GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT & lppeUserPlaneMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) {
+ mask |= (1<<1);
+ }
+ return mask;
+}
+
+GnssConfigLppeUserPlaneMask
+GnssAdapter::convertLppeUp(const uint32_t lppeUserPlaneMask)
+{
+ GnssConfigLppeUserPlaneMask mask = 0;
+ if ((1<<0) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT;
+ }
+ if ((1<<1) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT;
+ }
+ return mask;
+}
+
+uint32_t
+GnssAdapter::convertAGloProt(const GnssConfigAGlonassPositionProtocolMask aGloPositionProtocolMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_RRC_CONTROL_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_RRLP_USER_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<1);
+ }
+ if (GNSS_CONFIG_LLP_USER_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<2);
+ }
+ if (GNSS_CONFIG_LLP_CONTROL_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<3);
+ }
+ return mask;
+}
+
+uint32_t
+GnssAdapter::convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl)
+{
+ switch (emergencyPdnForEmergencySupl) {
+ case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES:
+ return 1;
+ case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO:
+ default:
+ return 0;
+ }
+}
+
+uint32_t
+GnssAdapter::convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices)
+{
+ switch (suplEmergencyServices) {
+ case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES:
+ return 1;
+ case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO:
+ default:
+ return 0;
+ }
+}
+
+uint32_t
+GnssAdapter::convertSuplMode(const GnssConfigSuplModeMask suplModeMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_SUPL_MODE_MSB & suplModeMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_SUPL_MODE_MSA & suplModeMask) {
+ mask |= (1<<1);
+ }
+ return mask;
+}
+
+bool
+GnssAdapter::resolveInAddress(const char* hostAddress, struct in_addr* inAddress)
+{
+ bool ret = true;
+
+ struct hostent* hp;
+ hp = gethostbyname(hostAddress);
+ if (hp != NULL) { /* DNS OK */
+ memcpy(inAddress, hp->h_addr_list[0], hp->h_length);
+ } else {
+ /* Try IP representation */
+ if (inet_aton(hostAddress, inAddress) == 0) {
+ /* IP not valid */
+ LOC_LOGE("%s]: DNS query on '%s' failed", __func__, hostAddress);
+ ret = false;
+ }
+ }
+
+ return ret;
+}
+
+void
+GnssAdapter::readConfigCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgReadConfig : public LocMsg {
+ GnssAdapter* mAdapter;
+ ContextBase& mContext;
+ inline MsgReadConfig(GnssAdapter* adapter,
+ ContextBase& context) :
+ LocMsg(),
+ mAdapter(adapter),
+ mContext(context) {}
+ inline virtual void proc() const {
+ // reads config into mContext->mGps_conf
+ mContext.readConfig();
+ mContext.requestUlp((LocAdapterBase*)mAdapter, mContext.getCarrierCapabilities());
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgReadConfig(this, *mContext));
+ }
+}
+
+void
+GnssAdapter::setConfigCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgSetConfig : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgSetConfig(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ mApi.setSUPLVersion(mAdapter.convertSuplVersion(ContextBase::mGps_conf.SUPL_VER));
+ mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE));
+ mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE,
+ ContextBase::mSap_conf.SENSOR_PROVIDER);
+ mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT);
+ mApi.setLPPeProtocolCp(
+ mAdapter.convertLppeCp(ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY));
+ mApi.setLPPeProtocolUp(
+ mAdapter.convertLppeUp(ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY));
+ if (NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) {
+ mApi.setNMEATypes(LOC_NMEA_ALL_SUPPORTED_MASK);
+ }
+ mApi.setXtraVersionCheck(ContextBase::mGps_conf.XTRA_VERSION_CHECK);
+ if (ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
+ mApi.setSensorProperties(
+ ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
+ ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK,
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY);
+ }
+ mApi.setSensorPerfControlConfig(
+ ContextBase::mSap_conf.SENSOR_CONTROL_MODE,
+ ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
+ ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
+ ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
+ ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
+ ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
+ ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
+ ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
+ ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
+ ContextBase::mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK);
+ }
+ };
+
+ sendMsg(new MsgSetConfig(*this, *mLocApi));
+}
+
+uint32_t*
+GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
+{
+ // count the number of bits set
+ GnssConfigFlagsMask flagsCopy = config.flags;
+ size_t count = 0;
+ while (flagsCopy > 0) {
+ if (flagsCopy & 1) {
+ count++;
+ }
+ flagsCopy >>= 1;
+ }
+ std::string idsString = "[";
+ uint32_t* ids = NULL;
+ if (count > 0) {
+ ids = new uint32_t[count];
+ for (size_t i=0; i < count; ++i) {
+ ids[i] = generateSessionId();
+ IF_LOC_LOGD {
+ idsString += std::to_string(ids[i]) + " ";
+ }
+ }
+ }
+ idsString += "]";
+
+ LOC_LOGD("%s]: ids %s flags 0x%X", __func__, idsString.c_str(), config.flags);
+
+ struct MsgGnssUpdateConfig : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ GnssConfig mConfig;
+ uint32_t* mIds;
+ size_t mCount;
+ inline MsgGnssUpdateConfig(GnssAdapter& adapter,
+ LocApiBase& api,
+ GnssConfig config,
+ uint32_t* ids,
+ size_t count) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mConfig(config),
+ mIds(ids),
+ mCount(count) {}
+ inline virtual ~MsgGnssUpdateConfig()
+ {
+ delete[] mIds;
+ }
+ inline virtual void proc() const {
+ //const size_t MAX_BITS_COUNT = 10;
+ //LocationError errs[MAX_BITS_COUNT] = {};
+ LocationError* errs = new LocationError[mCount];
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t index = 0;
+
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) {
+ uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock);
+ ContextBase::mGps_conf.GPS_LOCK = newGpsLock;
+ if (0 == mAdapter.getPowerVoteId()) {
+ err = mApi.setGpsLock(mConfig.gpsLock);
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) {
+ uint32_t newSuplVersion = mAdapter.convertSuplVersion(mConfig.suplVersion);
+ if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER) {
+ ContextBase::mGps_conf.SUPL_VER = newSuplVersion;
+ err = mApi.setSUPLVersion(mConfig.suplVersion);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
+ if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) {
+ char serverUrl[MAX_URL_LEN] = {};
+ uint32_t length = 0;
+ const char noHost[] = "NONE";
+ if (NULL == mConfig.assistanceServer.hostName ||
+ strncasecmp(noHost,
+ mConfig.assistanceServer.hostName,
+ sizeof(noHost)) == 0) {
+ } else {
+ length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u",
+ mConfig.assistanceServer.hostName,
+ mConfig.assistanceServer.port);
+ }
+
+ if (sizeof(serverUrl) > length) {
+ err = mApi.setServer(serverUrl, length);
+ } else {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ }
+ } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) {
+ struct in_addr addr;
+ if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, &addr)) {
+ LOC_LOGE("%s]: hostName %s cannot be resolved",
+ __func__, mConfig.assistanceServer.hostName);
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ unsigned int ip = htonl(addr.s_addr);
+ err = mApi.setServer(ip, mConfig.assistanceServer.port,
+ LOC_AGPS_CDMA_PDE_SERVER);
+ }
+ } else {
+ LOC_LOGE("%s]: Not a valid gnss assistance type %u",
+ __func__, mConfig.assistanceServer.type);
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) {
+ uint32_t newLppProfile = mAdapter.convertLppProfile(mConfig.lppProfile);
+ if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE) {
+ ContextBase::mGps_conf.LPP_PROFILE = newLppProfile;
+ err = mApi.setLPPConfig(mConfig.lppProfile);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) {
+ uint32_t newLppeControlPlaneMask =
+ mAdapter.convertLppeCp(mConfig.lppeControlPlaneMask);
+ if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) {
+ ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask;
+ err = mApi.setLPPeProtocolCp(mConfig.lppeControlPlaneMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) {
+ uint32_t newLppeUserPlaneMask =
+ mAdapter.convertLppeUp(mConfig.lppeUserPlaneMask);
+ if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) {
+ ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask;
+ err = mApi.setLPPeProtocolUp(mConfig.lppeUserPlaneMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) {
+ uint32_t newAGloProtMask =
+ mAdapter.convertAGloProt(mConfig.aGlonassPositionProtocolMask);
+ if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
+ ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask;
+ err = mApi.setAGLONASSProtocol(mConfig.aGlonassPositionProtocolMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) {
+ uint32_t newEP4ES = mAdapter.convertEP4ES(mConfig.emergencyPdnForEmergencySupl);
+ if (newEP4ES != ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+ ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = newEP4ES;
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) {
+ uint32_t newSuplEs = mAdapter.convertSuplEs(mConfig.suplEmergencyServices);
+ if (newSuplEs != ContextBase::mGps_conf.SUPL_ES) {
+ ContextBase::mGps_conf.SUPL_ES = newSuplEs;
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) {
+ uint32_t newSuplMode = mAdapter.convertSuplMode(mConfig.suplModeMask);
+ if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) {
+ ContextBase::mGps_conf.SUPL_MODE = newSuplMode;
+ mAdapter.getUlpProxy()->setCapabilities(
+ ContextBase::getCarrierCapabilities());
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+
+ mAdapter.reportResponse(index, errs, mIds);
+ delete[] errs;
+ }
+ };
+
+ if (NULL != ids) {
+ sendMsg(new MsgGnssUpdateConfig(*this, *mLocApi, config, ids, count));
+ } else {
+ LOC_LOGE("%s]: No GNSS config items to update", __func__);
+ }
+
+ return ids;
+}
+
+uint32_t
+GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: client %p id %u", __func__, sessionId);
+
+ struct MsgDeleteAidingData : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ uint32_t mSessionId;
+ GnssAidingData mData;
+ inline MsgDeleteAidingData(GnssAdapter& adapter,
+ LocApiBase& api,
+ uint32_t sessionId,
+ GnssAidingData& data) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mSessionId(sessionId),
+ mData(data) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ #ifdef TARGET_BUILD_VARIANT_USER
+ err = LOCATION_ERROR_NOT_SUPPORTED;
+ #endif
+ if (LOCATION_ERROR_SUCCESS == err) {
+ err = mApi.deleteAidingData(mData);
+ }
+ mAdapter.reportResponse(err, mSessionId);
+ }
+ };
+
+ sendMsg(new MsgDeleteAidingData(*this, *mLocApi, sessionId, data));
+ return sessionId;
+}
+
+void
+GnssAdapter::injectLocationCommand(double latitude, double longitude, float accuracy)
+{
+ LOC_LOGD("%s]: latitude %8.4f longitude %8.4f accuracy %8.4f",
+ __func__, latitude, longitude, accuracy);
+
+ struct MsgInjectLocation : public LocMsg {
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ double mLatitude;
+ double mLongitude;
+ float mAccuracy;
+ inline MsgInjectLocation(LocApiBase& api,
+ ContextBase& context,
+ double latitude,
+ double longitude,
+ float accuracy) :
+ LocMsg(),
+ mApi(api),
+ mContext(context),
+ mLatitude(latitude),
+ mLongitude(longitude),
+ mAccuracy(accuracy) {}
+ inline virtual void proc() const {
+ if (!mContext.hasCPIExtendedCapabilities()) {
+ mApi.injectPosition(mLatitude, mLongitude, mAccuracy);
+ }
+ }
+ };
+
+ sendMsg(new MsgInjectLocation(*mLocApi, *mContext, latitude, longitude, accuracy));
+}
+
+void
+GnssAdapter::injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty)
+{
+ LOC_LOGD("%s]: time %lld timeReference %lld uncertainty %d",
+ __func__, time, timeReference, uncertainty);
+
+ struct MsgInjectTime : public LocMsg {
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ int64_t mTime;
+ int64_t mTimeReference;
+ int32_t mUncertainty;
+ inline MsgInjectTime(LocApiBase& api,
+ ContextBase& context,
+ int64_t time,
+ int64_t timeReference,
+ int32_t uncertainty) :
+ LocMsg(),
+ mApi(api),
+ mContext(context),
+ mTime(time),
+ mTimeReference(timeReference),
+ mUncertainty(uncertainty) {}
+ inline virtual void proc() const {
+ mApi.setTime(mTime, mTimeReference, mUncertainty);
+ }
+ };
+
+ sendMsg(new MsgInjectTime(*mLocApi, *mContext, time, timeReference, uncertainty));
+}
+
+void
+GnssAdapter::setUlpProxyCommand(UlpProxyBase* ulp)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgSetUlpProxy : public LocMsg {
+ GnssAdapter& mAdapter;
+ UlpProxyBase* mUlp;
+ inline MsgSetUlpProxy(GnssAdapter& adapter,
+ UlpProxyBase* ulp) :
+ LocMsg(),
+ mAdapter(adapter),
+ mUlp(ulp) {}
+ inline virtual void proc() const {
+ mAdapter.setUlpProxy(mUlp);
+ }
+ };
+
+ sendMsg(new MsgSetUlpProxy(*this, ulp));
+}
+
+void
+GnssAdapter::setUlpProxy(UlpProxyBase* ulp)
+{
+ if (ulp == mUlpProxy) {
+ //This takes care of the case when double initalization happens
+ //and we get the same object back for UlpProxyBase . Do nothing
+ return;
+ }
+
+ LOC_LOGV("%s]: %p", __func__, ulp);
+ if (NULL == ulp) {
+ LOC_LOGE("%s]: ulp pointer is NULL", __func__);
+ ulp = new UlpProxyBase();
+ }
+
+ if (LOC_POSITION_MODE_INVALID != mUlpProxy->mPosMode.mode) {
+ // need to send this mode and start msg to ULP
+ ulp->sendFixMode(mUlpProxy->mPosMode);
+ }
+
+ if (mUlpProxy->mFixSet) {
+ ulp->sendStartFix();
+ }
+
+ delete mUlpProxy;
+ mUlpProxy = ulp;
+}
+
+void
+GnssAdapter::addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+
+ struct MsgAddClient : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ const LocationCallbacks mCallbacks;
+ inline MsgAddClient(GnssAdapter& adapter,
+ LocationAPI* client,
+ const LocationCallbacks& callbacks) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client),
+ mCallbacks(callbacks) {}
+ inline virtual void proc() const {
+ mAdapter.saveClient(mClient, mCallbacks);
+ }
+ };
+
+ sendMsg(new MsgAddClient(*this, client, callbacks));
+}
+
+void
+GnssAdapter::removeClientCommand(LocationAPI* client)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+
+ struct MsgRemoveClient : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ inline MsgRemoveClient(GnssAdapter& adapter,
+ LocationAPI* client) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client) {}
+ inline virtual void proc() const {
+ mAdapter.stopClientSessions(mClient);
+ mAdapter.eraseClient(mClient);
+ }
+ };
+
+ sendMsg(new MsgRemoveClient(*this, client));
+}
+
+void
+GnssAdapter::stopClientSessions(LocationAPI* client)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end();) {
+ if (client == it->first.client) {
+ LocationError err = stopTrackingMultiplex(it->first.client, it->first.id);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ it = mTrackingSessions.erase(it);
+ continue;
+ }
+ }
+ ++it; // increment only when not erasing an iterator
+ }
+
+}
+
+void
+GnssAdapter::updateClientsEventMask()
+{
+ LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (it->second.trackingCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT;
+ }
+ if (it->second.gnssNiCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
+ }
+ if (it->second.gnssSvCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_SATELLITE_REPORT;
+ }
+ if (it->second.gnssNmeaCb != nullptr &&
+ NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) {
+ mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT;
+ }
+ if (it->second.gnssMeasurementsCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
+ }
+ }
+ updateEvtMask(mask, LOC_REGISTRATION_MASK_SET);
+}
+
+void
+GnssAdapter::handleEngineUpEvent()
+{
+ struct MsgRestartSessions : public LocMsg {
+ GnssAdapter& mAdapter;
+ inline MsgRestartSessions(GnssAdapter& adapter) :
+ LocMsg(),
+ mAdapter(adapter) {}
+ virtual void proc() const {
+ mAdapter.restartSessions();
+ }
+ };
+
+ setConfigCommand();
+ sendMsg(new MsgRestartSessions(*this));
+}
+
+void
+GnssAdapter::restartSessions()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ if (mTrackingSessions.empty()) {
+ return;
+ }
+
+ // get the LocationOptions that has the smallest interval, which should be the active one
+ LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) {
+ if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet
+ it->second.minInterval < smallestIntervalOptions.minInterval) {
+ smallestIntervalOptions = it->second;
+ }
+ }
+
+ startTracking(smallestIntervalOptions);
+}
+
+void
+GnssAdapter::requestCapabilitiesCommand(LocationAPI* client)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgRequestCapabilities : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ inline MsgRequestCapabilities(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client) {}
+ inline virtual void proc() const {
+ LocationCallbacks callbacks = mAdapter.getClientCallbacks(mClient);
+ if (callbacks.capabilitiesCb == nullptr) {
+ LOC_LOGE("%s]: capabilitiesCb is NULL", __func__);
+ return;
+ }
+
+ LocationCapabilitiesMask mask = {};
+ // time based tracking always supported
+ mask |= LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT;
+ if (mApi.isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)){
+ mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT |
+ LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT;
+ }
+ if (mApi.isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) {
+ mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT;
+ }
+ // geofence always supported
+ mask |= LOCATION_CAPABILITIES_GEOFENCE_BIT;
+ if (mApi.gnssConstellationConfig()) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT;
+ }
+ uint32_t carrierCapabilities = ContextBase::getCarrierCapabilities();
+ if (carrierCapabilities & LOC_GPS_CAPABILITY_MSB) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MSB_BIT;
+ }
+ if (LOC_GPS_CAPABILITY_MSA & carrierCapabilities) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MSA_BIT;
+ }
+
+ callbacks.capabilitiesCb(mask);
+ }
+ };
+
+ sendMsg(new MsgRequestCapabilities(*this, *mLocApi, client));
+}
+
+LocationCallbacks
+GnssAdapter::getClientCallbacks(LocationAPI* client)
+{
+ LocationCallbacks callbacks = {};
+ auto it = mClientData.find(client);
+ if (it != mClientData.end()) {
+ callbacks = it->second;
+ }
+ return callbacks;
+}
+
+void
+GnssAdapter::saveClient(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ mClientData[client] = callbacks;
+ updateClientsEventMask();
+}
+
+void
+GnssAdapter::eraseClient(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ if (it != mClientData.end()) {
+ mClientData.erase(it);
+ }
+ updateClientsEventMask();
+}
+
+bool
+GnssAdapter::hasTrackingCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.trackingCb);
+}
+
+bool
+GnssAdapter::hasMeasurementsCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.gnssMeasurementsCb);
+}
+
+bool
+GnssAdapter::isTrackingSession(LocationAPI* client, uint32_t sessionId)
+{
+ LocationSessionKey key(client, sessionId);
+ return (mTrackingSessions.find(key) != mTrackingSessions.end());
+}
+
+void
+GnssAdapter::saveTrackingSession(LocationAPI* client, uint32_t sessionId,
+ const LocationOptions& options)
+{
+ LocationSessionKey key(client, sessionId);
+ mTrackingSessions[key] = options;
+}
+
+void
+GnssAdapter::eraseTrackingSession(LocationAPI* client, uint32_t sessionId)
+{
+ LocationSessionKey key(client, sessionId);
+ auto it = mTrackingSessions.find(key);
+ if (it != mTrackingSessions.end()) {
+ mTrackingSessions.erase(it);
+ }
+
+}
+
+void
+GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId)
+{
+ LOC_LOGD("%s]: client %p id %u err %u", __func__, client, sessionId, err);
+
+ auto it = mClientData.find(client);
+ if (it != mClientData.end() &&
+ it->second.responseCb != nullptr) {
+ it->second.responseCb(err, sessionId);
+ } else {
+ LOC_LOGW("%s]: client %p id %u not found in data", __func__, client, sessionId);
+ }
+}
+
+void
+GnssAdapter::reportResponse(LocationError err, uint32_t sessionId)
+{
+ LOC_LOGD("%s]: id %u err %u", __func__, sessionId, err);
+
+ if (mControlCallbacks.size > 0 && mControlCallbacks.responseCb != nullptr) {
+ mControlCallbacks.responseCb(err, sessionId);
+ } else {
+ LOC_LOGW("%s]: control client response callback not found", __func__);
+ }
+}
+
+void
+GnssAdapter::reportResponse(size_t count, LocationError* errs, uint32_t* ids)
+{
+ IF_LOC_LOGD {
+ std::string idsString = "[";
+ std::string errsString = "[";
+ if (NULL != ids && NULL != errs) {
+ for (size_t i=0; i < count; ++i) {
+ idsString += std::to_string(ids[i]) + " ";
+ errsString += std::to_string(errs[i]) + " ";
+ }
+ }
+ idsString += "]";
+ errsString += "]";
+
+ LOC_LOGD("%s]: ids %s errs %s",
+ __func__, idsString.c_str(), errsString.c_str());
+ }
+
+ if (mControlCallbacks.size > 0 && mControlCallbacks.collectiveResponseCb != nullptr) {
+ mControlCallbacks.collectiveResponseCb(count, errs, ids);
+ } else {
+ LOC_LOGW("%s]: control client callback not found", __func__);
+ }
+}
+
+uint32_t
+GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: client %p id %u minInterval %u mode %u",
+ __func__, client, sessionId, options.minInterval, options.mode);
+
+ struct MsgStartTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ LocationOptions mOptions;
+ inline MsgStartTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId,
+ LocationOptions options) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId),
+ mOptions(options) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mAdapter.hasTrackingCallback(mClient) &&
+ !mAdapter.hasMeasurementsCallback(mClient)) {
+ err = LOCATION_ERROR_CALLBACK_MISSING;
+ } else if (0 == mOptions.size) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.startTrackingMultiplex(mOptions);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.saveTrackingSession(mClient, mSessionId, mOptions);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ };
+
+ sendMsg(new MsgStartTracking(*this, *mLocApi, client, sessionId, options));
+ return sessionId;
+
+}
+
+LocationError
+GnssAdapter::startTrackingMultiplex(const LocationOptions& options)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ bool updateTrackingSession = false;
+
+ if (mTrackingSessions.empty()) {
+ err = startTracking(options);
+ } else {
+ // get the LocationOptions that has the smallest interval, which should be the active one
+ LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) {
+ if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet
+ it->second.minInterval < smallestIntervalOptions.minInterval) {
+ smallestIntervalOptions = it->second;
+ }
+ }
+ // if new session's minInterval is smaller than any in other sessions
+ if (options.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with new options
+ err = startTracking(options);
+ }
+ }
+
+ return err;
+}
+
+LocationError
+GnssAdapter::startTracking(const LocationOptions& options)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ LocPosMode locPosMode = {};
+ convertOptions(locPosMode, options);
+ if (!mUlpProxy->sendFixMode(locPosMode)) {
+ // do nothing
+ }
+ if (!mUlpProxy->sendStartFix()) {
+ loc_api_adapter_err apiErr = mLocApi->startFix(locPosMode);
+ if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) {
+ err = LOCATION_ERROR_SUCCESS;
+ // save supl mode, which is used for NMEA generation
+ setSuplMode(options.mode);
+ } else {
+ err = LOCATION_ERROR_GENERAL_FAILURE;
+ }
+ }
+
+ return err;
+}
+
+void
+GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode)
+{
+ LOC_LOGD("%s]: min_interval %u mode %u",
+ __func__, locPosMode.min_interval, locPosMode.mode);
+
+ struct MsgSetPositionMode : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocPosMode mLocPosMode;
+ inline MsgSetPositionMode(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocPosMode& locPosMode) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mLocPosMode(locPosMode) {}
+ inline virtual void proc() const {
+ // saves the mode in adapter to be used when startTrackingCommand is called from ULP
+ mAdapter.setUlpPositionMode(mLocPosMode);
+ mApi.setPositionMode(mLocPosMode);
+ }
+ };
+
+ sendMsg(new MsgSetPositionMode(*this, *mLocApi, locPosMode));
+}
+
+void
+GnssAdapter::startTrackingCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgStartTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgStartTracking(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ // we get this call from ULP, so just call LocApi without multiplexing because
+ // ulp would be doing the multiplexing for us if it is present
+ LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode();
+ mApi.startFix(ulpPositionMode);
+ // save supl mode, which is used for NMEA generation
+ mAdapter.setSuplMode((GnssSuplMode)ulpPositionMode.mode);
+ }
+ };
+
+ sendMsg(new MsgStartTracking(*this, *mLocApi));
+}
+
+void
+GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id,
+ LocationOptions& options)
+{
+ LOC_LOGD("%s]: client %p id %u minInterval %u mode %u",
+ __func__, client, id, options.minInterval, options.mode);
+
+ struct MsgUpdateTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ LocationOptions mOptions;
+ inline MsgUpdateTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId,
+ LocationOptions options) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId),
+ mOptions(options) {}
+ inline virtual void proc() const {
+ if (mAdapter.isTrackingSession(mClient, mSessionId)) {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (0 == mOptions.size) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.startTrackingMultiplex(mOptions);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.saveTrackingSession(mClient, mSessionId, mOptions);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ // we do not reportResponse for the case where there is no existing tracking session
+ // for the client and id being used, since updateTrackingCommand can be sent to both
+ // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response
+ }
+ };
+
+ sendMsg(new MsgUpdateTracking(*this, *mLocApi, client, id, options));
+}
+
+void
+GnssAdapter::stopTrackingCommand(LocationAPI* client, uint32_t id)
+{
+ LOC_LOGD("%s]: client %p id %u", __func__, client, id);
+
+ struct MsgStopTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ inline MsgStopTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId) {}
+ inline virtual void proc() const {
+ if (mAdapter.isTrackingSession(mClient, mSessionId)) {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.stopTrackingMultiplex(mClient, mSessionId);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.eraseTrackingSession(mClient, mSessionId);
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ // we do not reportResponse for the case where there is no existing tracking session
+ // for the client and id being used, since stopTrackingCommand can be sent to both
+ // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response
+
+ }
+ };
+
+ sendMsg(new MsgStopTracking(*this, *mLocApi, client, id));
+}
+
+LocationError
+GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+
+ if (1 == mTrackingSessions.size()) {
+ err = stopTracking();
+ } else {
+ LocationSessionKey key(client, id);
+
+ // get the session we are stopping
+ auto it = mTrackingSessions.find(key);
+ if (it != mTrackingSessions.end()) {
+ // find the next smallest interval, other than the session we are stopping
+ LocationOptions smallestIntervalOptions; // size will be zero until set for the first time
+ for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) {
+ // if session is not the one we are stopping and either smallest interval is not set
+ // or there is a new smallest interval, then set the new smallest interval
+ if (it2->first != key && (0 == smallestIntervalOptions.size ||
+ it2->second.minInterval < smallestIntervalOptions.minInterval)) {
+ smallestIntervalOptions = it2->second;
+ }
+ }
+ // if session we are stopping has smaller interval then next smallest
+ if (it->second.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with next smallest interval
+ err = startTracking(smallestIntervalOptions);
+ }
+ }
+ }
+
+ return err;
+}
+
+LocationError
+GnssAdapter::stopTracking()
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mUlpProxy->sendStopFix()) {
+ loc_api_adapter_err apiErr = mLocApi->stopFix();
+ if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) {
+ err = LOCATION_ERROR_SUCCESS;
+ } else {
+ err = LOCATION_ERROR_GENERAL_FAILURE;
+ }
+ }
+
+ return err;
+}
+
+void
+GnssAdapter::stopTrackingCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgStopTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgStopTracking(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ // clear the position mode
+ LocPosMode mLocPosMode = {};
+ mLocPosMode.mode = LOC_POSITION_MODE_INVALID;
+ mAdapter.setUlpPositionMode(mLocPosMode);
+ // don't need to multiplex because ULP will do that for us if it is present
+ mApi.stopFix();
+ }
+ };
+
+ sendMsg(new MsgStopTracking(*this, *mLocApi));
+}
+
+void
+GnssAdapter::getZppCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgGetZpp : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgGetZpp(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ UlpLocation location = {};
+ LocPosTechMask techMask = LOC_POS_TECH_MASK_DEFAULT;
+ GpsLocationExtended locationExtended = {};
+ locationExtended.size = sizeof(locationExtended);
+
+ mApi.getBestAvailableZppFix(location.gpsLocation, techMask);
+ //Mark the location source as from ZPP
+ location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
+ location.position_source = ULP_LOCATION_IS_FROM_ZPP;
+
+ mAdapter.getUlpProxy()->reportPosition(location,
+ locationExtended,
+ LOC_SESS_SUCCESS,
+ techMask);
+ }
+ };
+
+ sendMsg(new MsgGetZpp(*this, *mLocApi));
+}
+
+bool
+GnssAdapter::hasNiNotifyCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.gnssNiCb);
+}
+
+void
+GnssAdapter::gnssNiResponseCommand(LocationAPI* client,
+ uint32_t id,
+ GnssNiResponse response)
+{
+ LOC_LOGD("%s]: client %p id %u response %u", __func__, client, id, response);
+
+ struct MsgGnssNiResponse : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ GnssNiResponse mResponse;
+ inline MsgGnssNiResponse(GnssAdapter& adapter,
+ LocationAPI* client,
+ uint32_t sessionId,
+ GnssNiResponse response) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client),
+ mSessionId(sessionId),
+ mResponse(response) {}
+ inline virtual void proc() const {
+ NiData& niData = mAdapter.getNiData();
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mAdapter.hasNiNotifyCallback(mClient)) {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ } else {
+ NiSession* pSession = NULL;
+ if (mSessionId == niData.sessionEs.reqID &&
+ NULL != niData.sessionEs.rawRequest) {
+ pSession = &niData.sessionEs;
+ // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
+ if (mResponse == GNSS_NI_RESPONSE_ACCEPT &&
+ NULL != niData.session.rawRequest) {
+ pthread_mutex_lock(&niData.session.tLock);
+ niData.session.resp = GNSS_NI_RESPONSE_IGNORE;
+ niData.session.respRecvd = true;
+ pthread_cond_signal(&niData.session.tCond);
+ pthread_mutex_unlock(&niData.session.tLock);
+ }
+ } else if (mSessionId == niData.session.reqID &&
+ NULL != niData.session.rawRequest) {
+ pSession = &niData.session;
+ }
+
+ if (pSession) {
+ LOC_LOGI("%s]: gnssNiResponseCommand: send user mResponse %u for id %u",
+ __func__, mResponse, mSessionId);
+ pthread_mutex_lock(&pSession->tLock);
+ pSession->resp = mResponse;
+ pSession->respRecvd = true;
+ pthread_cond_signal(&pSession->tCond);
+ pthread_mutex_unlock(&pSession->tLock);
+ } else {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ LOC_LOGE("%s]: gnssNiResponseCommand: id %u not an active session",
+ __func__, mSessionId);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ };
+
+ sendMsg(new MsgGnssNiResponse(*this, client, id, response));
+
+}
+
+void
+GnssAdapter::gnssNiResponseCommand(GnssNiResponse response, void* rawRequest)
+{
+ LOC_LOGD("%s]: response %u", __func__, response);
+
+ struct MsgGnssNiResponse : public LocMsg {
+ LocApiBase& mApi;
+ const GnssNiResponse mResponse;
+ const void* mPayload;
+ inline MsgGnssNiResponse(LocApiBase& api,
+ const GnssNiResponse response,
+ const void* rawRequest) :
+ LocMsg(),
+ mApi(api),
+ mResponse(response),
+ mPayload(rawRequest) {}
+ inline virtual ~MsgGnssNiResponse() {
+ // this is a bit weird since mPayload is not
+ // allocated by this class. But there is no better way.
+ // mPayload actually won't be NULL here.
+ free((void*)mPayload);
+ }
+ inline virtual void proc() const {
+ mApi.informNiResponse(mResponse, mPayload);
+ }
+ };
+
+ sendMsg(new MsgGnssNiResponse(*mLocApi, response, rawRequest));
+
+}
+
+uint32_t
+GnssAdapter::enableCommand(LocationTechnologyType techType)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: id %u techType %u", __func__, sessionId, techType);
+
+ struct MsgEnableGnss : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ uint32_t mSessionId;
+ LocationTechnologyType mTechType;
+ inline MsgEnableGnss(GnssAdapter& adapter,
+ LocApiBase& api,
+ ContextBase& context,
+ uint32_t sessionId,
+ LocationTechnologyType techType) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mContext(context),
+ mSessionId(sessionId),
+ mTechType(techType) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t powerVoteId = mAdapter.getPowerVoteId();
+ if (mTechType != LOCATION_TECHNOLOGY_TYPE_GNSS) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else if (powerVoteId > 0) {
+ err = LOCATION_ERROR_ALREADY_STARTED;
+ } else {
+ mContext.modemPowerVote(true);
+ mAdapter.setPowerVoteId(mSessionId);
+ mApi.setGpsLock(GNSS_CONFIG_GPS_LOCK_NONE);
+ }
+ mAdapter.reportResponse(err, mSessionId);
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgEnableGnss(*this, *mLocApi, *mContext, sessionId, techType));
+ } else {
+ LOC_LOGE("%s]: Context is NULL", __func__);
+ }
+
+ return sessionId;
+}
+
+void
+GnssAdapter::disableCommand(uint32_t id)
+{
+ LOC_LOGD("%s]: id %u", __func__, id);
+
+ struct MsgDisableGnss : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ uint32_t mSessionId;
+ inline MsgDisableGnss(GnssAdapter& adapter,
+ LocApiBase& api,
+ ContextBase& context,
+ uint32_t sessionId) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mContext(context),
+ mSessionId(sessionId) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t powerVoteId = mAdapter.getPowerVoteId();
+ if (powerVoteId != mSessionId) {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ } else {
+ mContext.modemPowerVote(false);
+ mAdapter.setPowerVoteId(0);
+ mApi.setGpsLock(mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK));
+ }
+ mAdapter.reportResponse(err, mSessionId);
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgDisableGnss(*this, *mLocApi, *mContext, id));
+ }
+
+}
+
+void
+GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask,
+ bool fromUlp)
+{
+ LOC_LOGD("%s]: fromUlp %u status %u", __func__, fromUlp, status);
+
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp) {
+ if (mUlpProxy->reportPosition(ulpLocation, locationExtended,
+ status, techMask)) {
+ return;
+ }
+ }
+
+ struct MsgReportPosition : public LocMsg {
+ GnssAdapter& mAdapter;
+ const UlpLocation mUlpLocation;
+ const GpsLocationExtended mLocationExtended;
+ loc_sess_status mStatus;
+ LocPosTechMask mTechMask;
+ inline MsgReportPosition(GnssAdapter& adapter,
+ const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ loc_sess_status status,
+ LocPosTechMask techMask) :
+ LocMsg(),
+ mAdapter(adapter),
+ mUlpLocation(ulpLocation),
+ mLocationExtended(locationExtended),
+ mStatus(status),
+ mTechMask(techMask) {}
+ inline virtual void proc() const {
+ mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask);
+ }
+ };
+
+ sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask));
+}
+
+void
+GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask)
+{
+ bool reported = false;
+ if (LOC_SESS_FAILURE == status) {
+ Location invalidLocation = {};
+ invalidLocation.size = sizeof(Location);
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.trackingCb) {
+ it->second.trackingCb(invalidLocation);
+ }
+ }
+ reported = true;
+ }
+ // what's in the else if is... (line by line)
+ // 1. this is a final fix; and
+ // 1.1 it is a Satellite fix; or
+ // 1.2 it is a sensor fix
+ // 2. (must be intermediate fix... implicit)
+ // 2.1 we accepte intermediate; and
+ // 2.2 it is NOT the case that
+ // 2.2.1 there is inaccuracy; and
+ // 2.2.2 we care about inaccuracy; and
+ // 2.2.3 the inaccuracy exceeds our tolerance
+ else if ((LOC_SESS_SUCCESS == status &&
+ ((LOC_POS_TECH_MASK_SATELLITE |
+ LOC_POS_TECH_MASK_SENSORS |
+ LOC_POS_TECH_MASK_HYBRID) &
+ techMask)) ||
+ (LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS &&
+ !((ulpLocation.gpsLocation.flags &
+ LOC_GPS_LOCATION_HAS_ACCURACY) &&
+ (ContextBase::mGps_conf.ACCURACY_THRES != 0) &&
+ (ulpLocation.gpsLocation.accuracy >
+ ContextBase::mGps_conf.ACCURACY_THRES)))) {
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) {
+ mGnssSvIdUsedInPosAvail = true;
+ mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids;
+ }
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.trackingCb) {
+ Location location = {};
+ convertLocation(location, ulpLocation.gpsLocation, techMask);
+ it->second.trackingCb(location);
+ }
+ if (nullptr != it->second.gnssLocationInfoCb) {
+ GnssLocationInfoNotification locationInfo = {};
+ convertLocationInfo(locationInfo, locationExtended);
+ it->second.gnssLocationInfoCb(locationInfo);
+ }
+ }
+ reported = true;
+ }
+
+ if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) {
+ if (reported && status != LOC_SESS_FAILURE) {
+ generateNmea(ulpLocation, locationExtended);
+ } else {
+ generateNmeaBlank();
+ }
+ }
+
+ // Free the allocated memory for rawData
+ UlpLocation* gp = (UlpLocation*)&(ulpLocation);
+ if (gp != NULL && gp->rawData != NULL)
+ {
+ delete (char*)gp->rawData;
+ gp->rawData = NULL;
+ gp->rawDataSize = 0;
+ }
+}
+
+void
+GnssAdapter::reportSvEvent(const GnssSvNotification& svNotify,
+ bool fromUlp)
+{
+ LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp);
+
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp) {
+ if (mUlpProxy->reportSv(svNotify)) {
+ return;
+ }
+ }
+
+ struct MsgReportSv : public LocMsg {
+ GnssAdapter& mAdapter;
+ const GnssSvNotification mSvNotify;
+ inline MsgReportSv(GnssAdapter& adapter,
+ const GnssSvNotification& svNotify) :
+ LocMsg(),
+ mAdapter(adapter),
+ mSvNotify(svNotify) {}
+ inline virtual void proc() const {
+ mAdapter.reportSv((GnssSvNotification&)mSvNotify);
+ }
+ };
+
+ sendMsg(new MsgReportSv(*this, svNotify));
+}
+
+void
+GnssAdapter::reportSv(GnssSvNotification& svNotify)
+{
+ if (mGnssSvIdUsedInPosAvail) {
+ int numSv = svNotify.count;
+ int16_t gnssSvId = 0;
+ int prnMin = 0;
+ uint64_t svUsedIdMask = 0;
+ for (int i=0; i < numSv; i++) {
+ gnssSvId = svNotify.gnssSvs[i].svId;
+ if (gnssSvId <= GPS_SV_PRN_MAX) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask;
+ prnMin = GPS_SV_PRN_MIN;
+ } else if ((gnssSvId >= GLO_SV_PRN_MIN) && (gnssSvId <= GLO_SV_PRN_MAX)) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask;
+ prnMin = GLO_SV_PRN_MIN;
+ } else if ((gnssSvId >= BDS_SV_PRN_MIN) && (gnssSvId <= BDS_SV_PRN_MAX)) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask;
+ prnMin = BDS_SV_PRN_MIN;
+ } else if ((gnssSvId >= GAL_SV_PRN_MIN) && (gnssSvId <= GAL_SV_PRN_MAX)) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask;
+ prnMin = GAL_SV_PRN_MIN;
+ }
+
+ // If SV ID was used in previous position fix, then set USED_IN_FIX
+ // flag, else clear the USED_IN_FIX flag.
+ if (svUsedIdMask & (1 << (gnssSvId - prnMin))) {
+ svNotify.gnssSvs[i].gnssSvOptionsMask |= GNSS_SV_OPTIONS_USED_IN_FIX_BIT;
+ } else {
+ svNotify.gnssSvs[i].gnssSvOptionsMask &= ~GNSS_SV_OPTIONS_USED_IN_FIX_BIT;
+ }
+ }
+ }
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssSvCb) {
+ it->second.gnssSvCb(svNotify);
+ }
+ }
+
+ if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) {
+ generateNmea(svNotify);
+ }
+
+ mGnssSvIdUsedInPosAvail = false;
+}
+
+void
+GnssAdapter::reportNmeaEvent(const char* nmea, size_t length, bool fromUlp)
+{
+ //LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp);
+
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp) {
+ if (mUlpProxy->reportNmea(nmea, length)) {
+ return;
+ }
+ }
+
+ struct MsgReportNmea : public LocMsg {
+ GnssAdapter& mAdapter;
+ const char* mNmea;
+ size_t mLength;
+ inline MsgReportNmea(GnssAdapter& adapter,
+ const char* nmea,
+ size_t length) :
+ LocMsg(),
+ mAdapter(adapter),
+ mNmea(new char[length]),
+ mLength(length) {
+ memcpy((void*)mNmea, (void*)nmea, length);
+ }
+ inline virtual ~MsgReportNmea()
+ {
+ delete[] mNmea;
+ }
+ inline virtual void proc() const {
+ mAdapter.reportNmea(mNmea, mLength);
+ }
+ };
+
+ sendMsg(new MsgReportNmea(*this, nmea, length));
+}
+
+void
+GnssAdapter::reportNmea(const char* nmea, size_t length)
+{
+ GnssNmeaNotification nmeaNotification = {};
+ nmeaNotification.size = sizeof(GnssNmeaNotification);
+
+ struct timeval tv;
+ gettimeofday(&tv, (struct timezone *) NULL);
+ int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
+ nmeaNotification.timestamp = now;
+ nmeaNotification.nmea = nmea;
+ nmeaNotification.length = length;
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssNmeaCb) {
+ it->second.gnssNmeaCb(nmeaNotification);
+ }
+ }
+
+}
+
+bool
+GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* data)
+{
+ LOC_LOGI("%s]: notif_type: %d, timeout: %d, default_resp: %d"
+ "requestor_id: %s (encoding: %d) text: %s text (encoding: %d) extras: %s",
+ __func__, notify.type, notify.timeout, notify.timeoutResponse,
+ notify.requestor, notify.requestorEncoding,
+ notify.message, notify.messageEncoding, notify.extras);
+
+ struct MsgReportNiNotify : public LocMsg {
+ GnssAdapter& mAdapter;
+ const GnssNiNotification mNotify;
+ const void* mData;
+ inline MsgReportNiNotify(GnssAdapter& adapter,
+ const GnssNiNotification& notify,
+ const void* data) :
+ LocMsg(),
+ mAdapter(adapter),
+ mNotify(notify),
+ mData(data) {}
+ inline virtual void proc() const {
+ mAdapter.requestNiNotify(mNotify, mData);
+ }
+ };
+
+ sendMsg(new MsgReportNiNotify(*this, notify, data));
+
+ return true;
+}
+
+static void* niThreadProc(void *args)
+{
+ NiSession* pSession = (NiSession*)args;
+ int rc = 0; /* return code from pthread calls */
+
+ struct timeval present_time;
+ struct timespec expire_time;
+
+ pthread_mutex_lock(&pSession->tLock);
+ /* Calculate absolute expire time */
+ gettimeofday(&present_time, NULL);
+ expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft;
+ expire_time.tv_nsec = present_time.tv_usec * 1000;
+ LOC_LOGD("%s]: time out set for abs time %ld with delay %d sec",
+ __func__, (long)expire_time.tv_sec, pSession->respTimeLeft);
+
+ while (!pSession->respRecvd) {
+ rc = pthread_cond_timedwait(&pSession->tCond,
+ &pSession->tLock,
+ &expire_time);
+ if (rc == ETIMEDOUT) {
+ pSession->resp = GNSS_NI_RESPONSE_NO_RESPONSE;
+ LOC_LOGD("%s]: time out after valting for specified time. Ret Val %d",
+ __func__, rc);
+ break;
+ }
+ }
+ LOC_LOGD("%s]: Java layer has sent us a user response and return value from "
+ "pthread_cond_timedwait = %d pSession->resp is %u", __func__, rc, pSession->resp);
+ pSession->respRecvd = false; /* Reset the user response flag for the next session*/
+
+ // adding this check to support modem restart, in which case, we need the thread
+ // to exit without calling sending data. We made sure that rawRequest is NULL in
+ // loc_eng_ni_reset_on_engine_restart()
+ GnssAdapter* adapter = pSession->adapter;
+ GnssNiResponse resp;
+ void* rawRequest = NULL;
+ bool sendResponse = false;
+
+ if (NULL != pSession->rawRequest) {
+ if (pSession->resp != GNSS_NI_RESPONSE_IGNORE) {
+ resp = pSession->resp;
+ rawRequest = pSession->rawRequest;
+ sendResponse = true;
+ } else {
+ free(pSession->rawRequest);
+ }
+ pSession->rawRequest = NULL;
+ }
+ pthread_mutex_unlock(&pSession->tLock);
+
+ pSession->respTimeLeft = 0;
+ pSession->reqID = 0;
+
+ if (sendResponse) {
+ adapter->gnssNiResponseCommand(resp, rawRequest);
+ }
+
+ return NULL;
+}
+
+bool
+GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data)
+{
+ NiSession* pSession = NULL;
+ gnssNiCallback gnssNiCb = nullptr;
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssNiCb) {
+ gnssNiCb = it->second.gnssNiCb;
+ break;
+ }
+ }
+ if (nullptr == gnssNiCb) {
+ EXIT_LOG(%s, "no clients with gnssNiCb.");
+ return false;
+ }
+
+ if (notify.type == GNSS_NI_TYPE_EMERGENCY_SUPL) {
+ if (NULL != mNiData.sessionEs.rawRequest) {
+ LOC_LOGI("%s]: supl es NI in progress, new supl es NI ignored, type: %d",
+ __func__, notify.type);
+ if (NULL != data) {
+ free((void*)data);
+ }
+ } else {
+ pSession = &mNiData.sessionEs;
+ }
+ } else {
+ if (NULL != mNiData.session.rawRequest ||
+ NULL != mNiData.sessionEs.rawRequest) {
+ LOC_LOGI("%s]: supl NI in progress, new supl NI ignored, type: %d",
+ __func__, notify.type);
+ if (NULL != data) {
+ free((void*)data);
+ }
+ } else {
+ pSession = &mNiData.session;
+ }
+ }
+
+ if (pSession) {
+ /* Save request */
+ pSession->rawRequest = (void*)data;
+ pSession->reqID = ++mNiData.reqIDCounter;
+ pSession->adapter = this;
+
+ int sessionId = pSession->reqID;
+
+ /* For robustness, spawn a thread at this point to timeout to clear up the notification
+ * status, even though the OEM layer in java does not do so.
+ **/
+ pSession->respTimeLeft =
+ 5 + (notify.timeout != 0 ? notify.timeout : LOC_NI_NO_RESPONSE_TIME);
+
+ int rc = 0;
+ rc = pthread_create(&pSession->thread, NULL, niThreadProc, pSession);
+ if (rc) {
+ LOC_LOGE("%s]: Loc NI thread is not created.", __func__);
+ }
+ rc = pthread_detach(pSession->thread);
+ if (rc) {
+ LOC_LOGE("%s]: Loc NI thread is not detached.", __func__);
+ }
+
+ if (nullptr != gnssNiCb) {
+ gnssNiCb(sessionId, notify);
+ }
+ }
+
+ return true;
+}
+
+void
+GnssAdapter::reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgReportGnssMeasurementData : public LocMsg {
+ GnssAdapter& mAdapter;
+ const GnssMeasurementsNotification mMeasurementsNotify;
+ inline MsgReportGnssMeasurementData(GnssAdapter& adapter,
+ const GnssMeasurementsNotification& measurementsNotify) :
+ LocMsg(),
+ mAdapter(adapter),
+ mMeasurementsNotify(measurementsNotify) {}
+ inline virtual void proc() const {
+ mAdapter.reportGnssMeasurementData(mMeasurementsNotify);
+ }
+ };
+
+ sendMsg(new MsgReportGnssMeasurementData(*this, measurementsNotify));
+}
+
+void
+GnssAdapter::reportGnssMeasurementData(const GnssMeasurementsNotification& measurementsNotify)
+{
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssMeasurementsCb) {
+ it->second.gnssMeasurementsCb(measurementsNotify);
+ }
+ }
+}
+
+void
+GnssAdapter::reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
+ mUlpProxy->reportSvMeasurement(svMeasurementSet);
+}
+
+void
+GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
+ mUlpProxy->reportSvPolynomial(svPolynomial);
+}
+
+int
+GnssAdapter::nmeaPutChecksum(char *nmea, size_t maxSize)
+{
+ uint8_t checksum = 0;
+ int length = 0;
+
+ nmea++; //skip the $
+ while (*nmea != '\0') {
+ checksum ^= *nmea++;
+ length++;
+ }
+
+ // length now contains nmea sentence string length not including $ sign.
+ int checksumLength = snprintf(nmea,(maxSize-length-1),"*%02X\r\n", checksum);
+
+ // total length of nmea sentence is length of nmea sentence inc $ sign plus
+ // length of checksum (+1 is to cover the $ character in the length).
+ return (length + checksumLength + 1);
+}
+
+void
+GnssAdapter::generateNmea(const GnssSvNotification& svNotify)
+{
+ char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
+
+ // ------$GPGSV------
+ NmeaSvMeta gpsSvMeta =
+ {GNSS_SV_TYPE_GPS, "GP", 0, 0};
+ generateNmeaGSV(svNotify, gpsSvMeta, sentence, sizeof(sentence));
+
+ // ------$GLGSV------
+ NmeaSvMeta gloSvMeta =
+ {GNSS_SV_TYPE_GLONASS, "GL", 0, GLONASS_SV_ID_OFFSET};
+ generateNmeaGSV(svNotify, gloSvMeta, sentence, sizeof(sentence));
+
+ // ------$GAGSV------
+ NmeaSvMeta galSvMeta =
+ {GNSS_SV_TYPE_GALILEO, "GA", 0, 0};
+ generateNmeaGSV(svNotify, galSvMeta, sentence, sizeof(sentence));
+}
+
+void
+GnssAdapter::generateNmea(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended)
+{
+
+ char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
+
+ time_t utcTime(ulpLocation.gpsLocation.timestamp/1000);
+ tm * pTm = gmtime(&utcTime);
+ if (NULL == pTm) {
+ LOC_LOGE("%s]: gmtime failed", __func__);
+ return;
+ }
+
+ uint32_t svUsedCount = 0;
+ uint32_t count = 0;
+ bool isCombinedFix = (mGnssSvIdUsedInPosition.gps_sv_used_ids_mask ? 1 : 0) +
+ (mGnssSvIdUsedInPosition.glo_sv_used_ids_mask ? 1 : 0) +
+ (mGnssSvIdUsedInPosition.gal_sv_used_ids_mask ? 1 : 0) > 1;
+ NmeaSvMeta gnssSvMeta =
+ {GNSS_SV_TYPE_GPS, isCombinedFix ? "GN" : "GP",
+ mGnssSvIdUsedInPosition.gps_sv_used_ids_mask, 0};
+
+ // ---$GPGSA/$GNGSA---
+ NmeaSvMeta gpsSvMeta =
+ {GNSS_SV_TYPE_GPS, isCombinedFix ? "GN" : "GP",
+ mGnssSvIdUsedInPosition.gps_sv_used_ids_mask, 0};
+ count = generateNmeaGSA(locationExtended, gpsSvMeta, sentence, sizeof(sentence));
+ if (count > 0) {
+ svUsedCount += count;
+ gnssSvMeta = gpsSvMeta;
+ }
+
+ // ---$GLGSA/$GNGSA---
+ NmeaSvMeta gloSvMeta =
+ {GNSS_SV_TYPE_GLONASS, isCombinedFix ? "GN" : "GL",
+ mGnssSvIdUsedInPosition.glo_sv_used_ids_mask, GLONASS_SV_ID_OFFSET};
+ count = generateNmeaGSA(locationExtended, gloSvMeta, sentence, sizeof(sentence));
+ if (count > 0) {
+ svUsedCount += count;
+ gnssSvMeta = gloSvMeta;
+ }
+
+ // ---$GAGSA/$GNGSA---
+ NmeaSvMeta galSvMeta =
+ {GNSS_SV_TYPE_GALILEO, isCombinedFix ? "GN" : "GA",
+ mGnssSvIdUsedInPosition.gal_sv_used_ids_mask, 0};
+ count = generateNmeaGSA(locationExtended, galSvMeta, sentence, sizeof(sentence));
+ if (count > 0) {
+ svUsedCount += count;
+ gnssSvMeta = galSvMeta;
+ }
+
+ // ---$GPVTG/$GLVTG/$GAVTG/$GNVTG---
+ generateNmeaVTG(ulpLocation, locationExtended, gnssSvMeta,
+ sentence, sizeof(sentence));
+
+ // ---$GPRMC/$GLRMC/$GARMC/$GNRMC---
+ generateNmeaRMC(ulpLocation, locationExtended, gnssSvMeta,
+ *pTm, sentence, sizeof(sentence));
+
+ // ---$GPGGA/$GLGGA/$GAGGA/$GNGGA---
+ generateNmeaGGA(ulpLocation, locationExtended, gnssSvMeta,
+ *pTm, svUsedCount, sentence, sizeof(sentence));
+
+}
+
+void
+GnssAdapter::generateNmeaBlank()
+{
+ char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
+ int length = 0;
+
+ strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence));
+ length = nmeaPutChecksum(sentence, sizeof(sentence));
+ reportNmeaEvent(sentence, length);
+
+ strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence));
+ length = nmeaPutChecksum(sentence, sizeof(sentence));
+ reportNmeaEvent(sentence, length);
+
+ strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence));
+ length = nmeaPutChecksum(sentence, sizeof(sentence));
+ reportNmeaEvent(sentence, length);
+
+ strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence));
+ length = nmeaPutChecksum(sentence, sizeof(sentence));
+ reportNmeaEvent(sentence, length);
+
+ strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence));
+ length = nmeaPutChecksum(sentence, sizeof(sentence));
+ reportNmeaEvent(sentence, length);
+}
+
+void
+GnssAdapter::generateNmeaGSV(const GnssSvNotification& svNotify, NmeaSvMeta& svMeta,
+ char* sentence, size_t size)
+{
+ if (!sentence || size == 0) {
+ LOC_LOGE("%s]: NMEA Error invalid argument.", __func__);
+ return;
+ }
+
+ char* pMarker = sentence;
+ int lengthRemaining = size;
+ int length = 0;
+ int sentenceCount = 0;
+ int sentenceNumber = 1;
+ int svCount = 0;
+ int sv = 1;
+
+ for (sv=1; sv <= svNotify.count; sv++) {
+ if (svMeta.svType == svNotify.gnssSvs[sv - 1].type) {
+ // cache the used in fix mask, as it will be needed to send $GPGSA
+ // during the position report
+ if (LOC_GNSS_SV_FLAGS_USED_IN_FIX ==
+ (svNotify.gnssSvs[sv - 1].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) {
+ svCount++;
+ }
+ }
+ }
+
+ if (svCount == 0) {
+ // no svs in view, so just send a blank $--GSV sentence
+ snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", svMeta.talker);
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+ return;
+ }
+
+ sv = 1;
+ sentenceNumber = 1;
+ sentenceCount = svCount / 4 + (svCount % 4 != 0);
+
+ while (sentenceNumber <= sentenceCount) {
+ pMarker = sentence;
+ lengthRemaining = size;
+
+ length = snprintf(pMarker, lengthRemaining, "$%sGSV,%d,%d,%02d",
+ svMeta.talker, sentenceCount, sentenceNumber, svCount);
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ for (int i=0; (sv <= svNotify.count) && (i < 4); sv++) {
+ if (svMeta.svType == svNotify.gnssSvs[sv - 1].type) {
+ length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
+ svNotify.gnssSvs[sv - 1].svId,
+ (int)(0.5 + svNotify.gnssSvs[sv - 1].elevation), //float to int
+ (int)(0.5 + svNotify.gnssSvs[sv - 1].azimuth)); //float to int
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (svNotify.gnssSvs[sv - 1].cN0Dbhz > 0) {
+ length = snprintf(pMarker, lengthRemaining,"%02d",
+ (int)(0.5 + svNotify.gnssSvs[sv - 1].cN0Dbhz)); //float to int
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+ }
+ i++;
+ }
+ }
+
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+ sentenceNumber++;
+ } //while
+}
+
+uint8_t
+GnssAdapter::generateNmeaGSA(const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, char* sentence, size_t size)
+{
+ if (!sentence || size == 0) {
+ LOC_LOGE("%s]: NMEA Error invalid arguments.", __func__);
+ return 0;
+ }
+
+ char* pMarker = sentence;
+ int lengthRemaining = size;
+ int length = 0;
+
+ uint8_t svUsedCount = 0;
+ uint32_t svUsedList[32] = {0};
+
+ char fixType = '\0';
+
+ uint32_t svIdOffset = svMeta.svIdOffset;
+ uint32_t mask = svMeta.mask;
+
+ for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) {
+ if (mask & 1) {
+ svUsedList[svUsedCount++] = i + svIdOffset;
+ }
+ mask = mask >> 1;
+ }
+
+ if (svUsedCount == 0 && LOC_GNSS_CONSTELLATION_GPS != svMeta.svType) {
+ return 0;
+ }
+
+ if (svUsedCount == 0) {
+ fixType = '1'; // no fix
+ } else if (svUsedCount <= 3) {
+ fixType = '2'; // 2D fix
+ } else {
+ fixType = '3'; // 3D fix
+ }
+
+ // Start printing the sentence
+ // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc
+ // a : Mode : A : Automatic, allowed to automatically switch 2D/3D
+ // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix)
+ // xx : 12 SV ID
+ // p.p : Position DOP (Dilution of Precision)
+ // h.h : Horizontal DOP
+ // v.v : Vertical DOP
+ // cc : Checksum value
+ length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", svMeta.talker, fixType);
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);;
+ return 0;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ // Add first 12 satellite IDs
+ for (uint8_t i = 0; i < 12; i++) {
+ if (i < svUsedCount) {
+ length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, ",");
+ }
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return 0;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+ }
+
+ // Add the position/horizontal/vertical DOP values
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) {
+ length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f",
+ locationExtended.pdop,
+ locationExtended.hdop,
+ locationExtended.vdop);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, ",,");
+ }
+
+ /* Sentence is ready, add checksum and broadcast */
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+
+ return svUsedCount;
+}
+
+void
+GnssAdapter::generateNmeaVTG(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, char* sentence, size_t size)
+{
+ if (!sentence || size == 0) {
+ LOC_LOGE("%s]: NMEA Error invalid arguments.", __func__);
+ return;
+ }
+
+ char* pMarker = sentence;
+ int lengthRemaining = size;
+ int length = 0;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING)
+ {
+ float magTrack = ulpLocation.gpsLocation.bearing;
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV)
+ {
+ float magTrack = ulpLocation.gpsLocation.bearing - locationExtended.magneticDeviation;
+ if (magTrack < 0.0)
+ magTrack += 360.0;
+ else if (magTrack > 360.0)
+ magTrack -= 360.0;
+ }
+
+ length = snprintf(pMarker, lengthRemaining, "$%sVTG,%.1lf,T,%.1lf,M,",
+ svMeta.talker, ulpLocation.gpsLocation.bearing, magTrack);
+ }
+ else
+ {
+ length = snprintf(pMarker, lengthRemaining, "$%sVTG,,T,,M,", svMeta.talker);
+ }
+
+ if (length < 0 || length >= lengthRemaining)
+ {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED)
+ {
+ float speedKnots = ulpLocation.gpsLocation.speed * (3600.0/1852.0);
+ float speedKmPerHour = ulpLocation.gpsLocation.speed * 3.6;
+
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour);
+ }
+ else
+ {
+ length = snprintf(pMarker, lengthRemaining, ",N,,K,");
+ }
+
+ if (length < 0 || length >= lengthRemaining)
+ {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
+ length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix
+ else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode)
+ length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous
+ else
+ length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential
+
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+}
+
+void
+GnssAdapter::generateNmeaRMC(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, tm& utcTime,
+ char* sentence, size_t size)
+{
+ if (!sentence || size == 0) {
+ LOC_LOGE("NMEA Error invalid arguments.");
+ return;
+ }
+
+ int utcYear = utcTime.tm_year % 100; // 2 digit year
+ int utcMonth = utcTime.tm_mon + 1; // tm_mon starts at zero
+ int utcDay = utcTime.tm_mday;
+ int utcHours = utcTime.tm_hour;
+ int utcMinutes = utcTime.tm_min;
+ int utcSeconds = utcTime.tm_sec;
+ int utcMSeconds = (ulpLocation.gpsLocation.timestamp)%1000;
+
+ char* pMarker = sentence;
+ int lengthRemaining = size;
+ int length = 0;
+
+ length = snprintf(pMarker, lengthRemaining, "$%sRMC,%02d%02d%02d.%02d,A," ,
+ svMeta.talker, utcHours, utcMinutes, utcSeconds,utcMSeconds/10);
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) {
+ double latitude = ulpLocation.gpsLocation.latitude;
+ double longitude = ulpLocation.gpsLocation.longitude;
+ char latHemisphere;
+ char lonHemisphere;
+ double latMinutes;
+ double lonMinutes;
+
+ if (latitude > 0) {
+ latHemisphere = 'N';
+ } else {
+ latHemisphere = 'S';
+ latitude *= -1.0;
+ }
+
+ if (longitude < 0) {
+ lonHemisphere = 'W';
+ longitude *= -1.0;
+ } else {
+ lonHemisphere = 'E';
+ }
+
+ latMinutes = fmod(latitude * 60.0 , 60.0);
+ lonMinutes = fmod(longitude * 60.0 , 60.0);
+
+ length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,",
+ (uint8_t)floor(latitude), latMinutes, latHemisphere,
+ (uint8_t)floor(longitude),lonMinutes, lonHemisphere);
+ } else {
+ length = snprintf(pMarker, lengthRemaining,",,,,");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) {
+ float speedKnots = ulpLocation.gpsLocation.speed * (3600.0/1852.0);
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, ",");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) {
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,", ulpLocation.gpsLocation.bearing);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, ",");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,",
+ utcDay, utcMonth, utcYear);
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) {
+ float magneticVariation = locationExtended.magneticDeviation;
+ char direction;
+ if (magneticVariation < 0.0) {
+ direction = 'W';
+ magneticVariation *= -1.0;
+ } else {
+ direction = 'E';
+ }
+
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,",
+ magneticVariation, direction);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, ",,");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) {
+ length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix
+ } else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode) {
+ length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous
+ } else {
+ length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential
+ }
+
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+}
+
+void
+GnssAdapter::generateNmeaGGA(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, tm& utcTime, uint32_t svUsedCount,
+ char* sentence, size_t size)
+{
+ if (!sentence || size == 0) {
+ LOC_LOGE("NMEA Error invalid arguments.");
+ return;
+ }
+
+ int utcYear = utcTime.tm_year % 100; // 2 digit year
+ int utcMonth = utcTime.tm_mon + 1; // tm_mon starts at zero
+ int utcDay = utcTime.tm_mday;
+ int utcHours = utcTime.tm_hour;
+ int utcMinutes = utcTime.tm_min;
+ int utcSeconds = utcTime.tm_sec;
+ int utcMSeconds = (ulpLocation.gpsLocation.timestamp)%1000;
+
+ char* pMarker = sentence;
+ int lengthRemaining = size;
+ int length = 0;
+
+ length = snprintf(pMarker, lengthRemaining, "$%sGGA,%02d%02d%02d.%02d," ,
+ svMeta.talker, utcHours, utcMinutes, utcSeconds, utcMSeconds/10);
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) {
+ double latitude = ulpLocation.gpsLocation.latitude;
+ double longitude = ulpLocation.gpsLocation.longitude;
+ char latHemisphere;
+ char lonHemisphere;
+ double latMinutes;
+ double lonMinutes;
+
+ if (latitude > 0) {
+ latHemisphere = 'N';
+ } else {
+ latHemisphere = 'S';
+ latitude *= -1.0;
+ }
+
+ if (longitude < 0) {
+ lonHemisphere = 'W';
+ longitude *= -1.0;
+ } else {
+ lonHemisphere = 'E';
+ }
+
+ latMinutes = fmod(latitude * 60.0 , 60.0);
+ lonMinutes = fmod(longitude * 60.0 , 60.0);
+
+ length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,",
+ (uint8_t)floor(latitude), latMinutes, latHemisphere,
+ (uint8_t)floor(longitude),lonMinutes, lonHemisphere);
+ } else {
+ length = snprintf(pMarker, lengthRemaining,",,,,");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ char gpsQuality;
+ if (!(ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) {
+ gpsQuality = '0'; // 0 means no fix
+ } else if (GNSS_SUPL_MODE_STANDALONE == mSuplMode) {
+ gpsQuality = '1'; // 1 means GPS fix
+ } else {
+ gpsQuality = '2'; // 2 means DGPS fix
+ }
+
+ // Number of satellites in use, 00-12
+ if (svUsedCount > MAX_SATELLITES_IN_USE) {
+ svUsedCount = MAX_SATELLITES_IN_USE;
+ }
+
+ // Add the position/horizontal/vertical DOP values
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) {
+ length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,",
+ gpsQuality, svUsedCount, locationExtended.hdop);
+ } else {
+ length = snprintf(pMarker, lengthRemaining, "%c,%02d,,",
+ gpsQuality, svUsedCount);
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL) {
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,M,",
+ locationExtended.altitudeMeanSeaLevel);
+ } else {
+ length = snprintf(pMarker, lengthRemaining,",,");
+ }
+
+ if (length < 0 || length >= lengthRemaining) {
+ LOC_LOGE("%s:%d]: NMEA Error in string formatting", __func__, __LINE__);
+ return;
+ }
+ pMarker += length;
+ lengthRemaining -= length;
+
+ if ((ulpLocation.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ALTITUDE) &&
+ (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)) {
+ length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,",
+ ulpLocation.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel);
+ } else {
+ length = snprintf(pMarker, lengthRemaining,",,,");
+ }
+
+ length = nmeaPutChecksum(sentence, size);
+ reportNmeaEvent(sentence, length);
+}
+
+/* INIT LOC AGPS MANAGER */
+void GnssAdapter::initAgpsCommand(void* statusV4Cb){
+
+ LOC_LOGI("GnssAdapter::initAgpsCommand");
+
+ /* Set ATL open/close callbacks */
+ AgpsAtlOpenStatusCb atlOpenStatusCb =
+ [this](int handle, int isSuccess, char* apn,
+ AGpsBearerType bearerType, AGpsExtType agpsType) {
+
+ mLocApi->atlOpenStatus(
+ handle, isSuccess, apn, bearerType, agpsType);
+ };
+ AgpsAtlCloseStatusCb atlCloseStatusCb =
+ [this](int handle, int isSuccess) {
+
+ mLocApi->atlCloseStatus(handle, isSuccess);
+ };
+
+ /* Register DS Client APIs */
+ AgpsDSClientInitFn dsClientInitFn =
+ [this](bool isDueToSSR) {
+
+ return mLocApi->initDataServiceClient(isDueToSSR);
+ };
+
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn =
+ [this] {
+
+ return mLocApi->openAndStartDataCall();
+ };
+
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn =
+ [this] {
+
+ mLocApi->stopDataCall();
+ };
+
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn =
+ [this] {
+
+ mLocApi->closeDataCall();
+ };
+
+ AgpsDSClientReleaseFn dsClientReleaseFn =
+ [this] {
+
+ mLocApi->releaseDataServiceClient();
+ };
+
+ /* Send Msg function */
+ SendMsgToAdapterMsgQueueFn sendMsgFn =
+ [this](LocMsg* msg) {
+
+ sendMsg(msg);
+ };
+
+ /* Message to initialize AGPS module */
+ struct AgpsMsgInit: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ AgpsFrameworkInterface::AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+
+ AgpsAtlOpenStatusCb mAtlOpenStatusCb;
+ AgpsAtlCloseStatusCb mAtlCloseStatusCb;
+
+ AgpsDSClientInitFn mDSClientInitFn;
+ AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn;
+ AgpsDSClientStopDataCallFn mDSClientStopDataCallFn;
+ AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn;
+ AgpsDSClientReleaseFn mDSClientReleaseFn;
+
+ SendMsgToAdapterMsgQueueFn mSendMsgFn;
+
+ inline AgpsMsgInit(AgpsManager* agpsManager,
+ AgpsFrameworkInterface::AgnssStatusIpV4Cb frameworkStatusV4Cb,
+ AgpsAtlOpenStatusCb atlOpenStatusCb,
+ AgpsAtlCloseStatusCb atlCloseStatusCb,
+ AgpsDSClientInitFn dsClientInitFn,
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
+ AgpsDSClientReleaseFn dsClientReleaseFn,
+ SendMsgToAdapterMsgQueueFn sendMsgFn) :
+ LocMsg(), mAgpsManager(agpsManager), mFrameworkStatusV4Cb(
+ frameworkStatusV4Cb), mAtlOpenStatusCb(atlOpenStatusCb), mAtlCloseStatusCb(
+ atlCloseStatusCb), mDSClientInitFn(dsClientInitFn), mDSClientOpenAndStartDataCallFn(
+ dsClientOpenAndStartDataCallFn), mDSClientStopDataCallFn(
+ dsClientStopDataCallFn), mDSClientCloseDataCallFn(
+ dsClientCloseDataCallFn), mDSClientReleaseFn(
+ dsClientReleaseFn), mSendMsgFn(sendMsgFn) {
+
+ LOC_LOGV("AgpsMsgInit");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgInit::proc()");
+
+ mAgpsManager->registerCallbacks(mFrameworkStatusV4Cb, mAtlOpenStatusCb,
+ mAtlCloseStatusCb, mDSClientInitFn,
+ mDSClientOpenAndStartDataCallFn, mDSClientStopDataCallFn,
+ mDSClientCloseDataCallFn, mDSClientReleaseFn, mSendMsgFn);
+
+ mAgpsManager->createAgpsStateMachines();
+ }
+ };
+
+ /* Send message to initialize AGPS Manager */
+ sendMsg(new AgpsMsgInit(
+ &mAgpsManager,
+ (AgpsFrameworkInterface::AgnssStatusIpV4Cb)statusV4Cb,
+ atlOpenStatusCb, atlCloseStatusCb,
+ dsClientInitFn, dsClientOpenAndStartDataCallFn,
+ dsClientStopDataCallFn, dsClientCloseDataCallFn,
+ dsClientReleaseFn,
+ sendMsgFn));
+}
+
+/* GnssAdapter::requestATL
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_OPEN_V02
+ * Triggers the AGPS state machine to setup AGPS call for below WWAN types:
+ * eQMI_LOC_WWAN_TYPE_INTERNET_V02
+ * eQMI_LOC_WWAN_TYPE_AGNSS_V02 */
+bool GnssAdapter::requestATL(int connHandle, LocAGpsType agpsType){
+
+ LOC_LOGI("GnssAdapter::requestATL");
+
+ sendMsg( new AgpsMsgRequestATL(
+ &mAgpsManager, connHandle, (AGpsExtType)agpsType));
+
+ return true;
+}
+
+/* GnssAdapter::requestSuplES
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_OPEN_V02
+ * Triggers the AGPS state machine to setup AGPS call for below WWAN types:
+ * eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY_V02 */
+bool GnssAdapter::requestSuplES(int connHandle){
+
+ LOC_LOGI("GnssAdapter::requestSuplES");
+
+ sendMsg( new AgpsMsgRequestATL(
+ &mAgpsManager, connHandle, LOC_AGPS_TYPE_SUPL_ES));
+
+ return true;
+}
+
+/* GnssAdapter::releaseATL
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_CLOSE_V02
+ * Triggers teardown of an existing AGPS call */
+bool GnssAdapter::releaseATL(int connHandle){
+
+ LOC_LOGI("GnssAdapter::releaseATL");
+
+ /* Release SUPL/INTERNET/SUPL_ES ATL */
+ struct AgpsMsgReleaseATL: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ int mConnHandle;
+
+ inline AgpsMsgReleaseATL(AgpsManager* agpsManager, int connHandle) :
+ LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle) {
+
+ LOC_LOGV("AgpsMsgReleaseATL");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgReleaseATL::proc()");
+ mAgpsManager->releaseATL(mConnHandle);
+ }
+ };
+
+ sendMsg( new AgpsMsgReleaseATL(&mAgpsManager, connHandle));
+
+ return true;
+}
+
+/* GnssAdapter::reportDataCallOpened
+ * DS Client data call opened successfully.
+ * Send message to AGPS Manager to handle. */
+bool GnssAdapter::reportDataCallOpened(){
+
+ LOC_LOGI("GnssAdapter::reportDataCallOpened");
+
+ struct AgpsMsgSuplEsOpened: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ inline AgpsMsgSuplEsOpened(AgpsManager* agpsManager) :
+ LocMsg(), mAgpsManager(agpsManager) {
+
+ LOC_LOGV("AgpsMsgSuplEsOpened");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgSuplEsOpened::proc()");
+ mAgpsManager->reportDataCallOpened();
+ }
+ };
+
+ sendMsg( new AgpsMsgSuplEsOpened(&mAgpsManager));
+
+ return true;
+}
+
+/* GnssAdapter::reportDataCallClosed
+ * DS Client data call closed.
+ * Send message to AGPS Manager to handle. */
+bool GnssAdapter::reportDataCallClosed(){
+
+ LOC_LOGI("GnssAdapter::reportDataCallClosed");
+
+ struct AgpsMsgSuplEsClosed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ inline AgpsMsgSuplEsClosed(AgpsManager* agpsManager) :
+ LocMsg(), mAgpsManager(agpsManager) {
+
+ LOC_LOGV("AgpsMsgSuplEsClosed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgSuplEsClosed::proc()");
+ mAgpsManager->reportDataCallClosed();
+ }
+ };
+
+ sendMsg( new AgpsMsgSuplEsClosed(&mAgpsManager));
+
+ return true;
+}
+
+void GnssAdapter::dataConnOpenCommand(
+ AGpsExtType agpsType,
+ const char* apnName, int apnLen, LocApnIpType ipType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnOpen");
+
+ struct AgpsMsgAtlOpenSuccess: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+ char* mApnName;
+ int mApnLen;
+ LocApnIpType mIpType;
+
+ inline AgpsMsgAtlOpenSuccess(AgpsManager* agpsManager, AGpsExtType agpsType,
+ const char* apnName, int apnLen, LocApnIpType ipType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType), mApnName(
+ new char[apnLen + 1]), mApnLen(apnLen), mIpType(ipType) {
+
+ LOC_LOGV("AgpsMsgAtlOpenSuccess");
+ memcpy(mApnName, apnName, apnLen);
+ mApnName[apnLen] = 0;
+ }
+
+ inline ~AgpsMsgAtlOpenSuccess() {
+ delete[] mApnName;
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlOpenSuccess::proc()");
+ mAgpsManager->reportAtlOpenSuccess(mAgpsType, mApnName, mApnLen,
+ mIpType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlOpenSuccess(
+ &mAgpsManager, (AGpsExtType)agpsType, apnName, apnLen, ipType));
+}
+
+void GnssAdapter::dataConnClosedCommand(AGpsExtType agpsType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnClosed");
+
+ struct AgpsMsgAtlClosed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgAtlClosed(AgpsManager* agpsManager, AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) {
+
+ LOC_LOGV("AgpsMsgAtlClosed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlClosed::proc()");
+ mAgpsManager->reportAtlClosed(mAgpsType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlClosed(&mAgpsManager, (AGpsExtType)agpsType));
+}
+
+void GnssAdapter::dataConnFailedCommand(AGpsExtType agpsType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnFailed");
+
+ struct AgpsMsgAtlOpenFailed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgAtlOpenFailed(AgpsManager* agpsManager, AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) {
+
+ LOC_LOGV("AgpsMsgAtlOpenFailed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlOpenFailed::proc()");
+ mAgpsManager->reportAtlOpenFailed(mAgpsType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlOpenFailed(&mAgpsManager, (AGpsExtType)agpsType));
+}
diff --git a/msm8998/gnss/GnssAdapter.h b/msm8998/gnss/GnssAdapter.h
new file mode 100644
index 0000000..cfba4ed
--- /dev/null
+++ b/msm8998/gnss/GnssAdapter.h
@@ -0,0 +1,279 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef GNSS_ADAPTER_H
+#define GNSS_ADAPTER_H
+
+#include <LocAdapterBase.h>
+#include <LocDualContext.h>
+#include <UlpProxyBase.h>
+#include <LocationAPI.h>
+#include <Agps.h>
+
+#define MAX_URL_LEN 256
+#define NMEA_SENTENCE_MAX_LENGTH 200
+#define GLONASS_SV_ID_OFFSET 64
+#define MAX_SATELLITES_IN_USE 12
+#define LOC_NI_NO_RESPONSE_TIME 20
+#define LOC_GPS_NI_RESPONSE_IGNORE 4
+
+class GnssAdapter;
+
+typedef struct {
+ pthread_t thread; /* NI thread */
+ uint32_t respTimeLeft; /* examine time for NI response */
+ bool respRecvd; /* NI User reponse received or not from Java layer*/
+ void* rawRequest;
+ uint32_t reqID; /* ID to check against response */
+ GnssNiResponse resp;
+ pthread_cond_t tCond;
+ pthread_mutex_t tLock;
+ GnssAdapter* adapter;
+} NiSession;
+typedef struct {
+ NiSession session; /* SUPL NI Session */
+ NiSession sessionEs; /* Emergency SUPL NI Session */
+ uint32_t reqIDCounter;
+} NiData;
+
+typedef enum {
+ NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA
+ NMEA_PROVIDER_MP // Modem Processor Provider of NMEA
+} NmeaProviderType;
+typedef struct {
+ GnssSvType svType;
+ const char* talker;
+ uint64_t mask;
+ uint32_t svIdOffset;
+} NmeaSvMeta;
+
+using namespace loc_core;
+
+class GnssAdapter : public LocAdapterBase {
+ /* ==== ULP ============================================================================ */
+ UlpProxyBase* mUlpProxy;
+
+ /* ==== CLIENT ========================================================================= */
+ typedef std::map<LocationAPI*, LocationCallbacks> ClientDataMap;
+ ClientDataMap mClientData;
+
+ /* ==== TRACKING ======================================================================= */
+ LocationSessionMap mTrackingSessions;
+ GnssSuplMode mSuplMode;
+ LocPosMode mUlpPositionMode;
+ GnssSvUsedInPosition mGnssSvIdUsedInPosition;
+ bool mGnssSvIdUsedInPosAvail;
+
+ /* ==== CONTROL ======================================================================== */
+ LocationControlCallbacks mControlCallbacks;
+ uint32_t mPowerVoteId;
+
+ /* ==== NI ============================================================================= */
+ NiData mNiData;
+
+ /* ==== AGPS ========================================================*/
+ // This must be initialized via initAgps()
+ AgpsManager mAgpsManager;
+
+ /*==== CONVERSION ===================================================================*/
+ static void convertOptions(LocPosMode& out, const LocationOptions& options);
+ static void convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
+ const LocPosTechMask techMask);
+ static void convertLocationInfo(GnssLocationInfoNotification& out,
+ const GpsLocationExtended& locationExtended);
+
+public:
+
+ GnssAdapter();
+ virtual ~GnssAdapter();
+
+ /* ==== SSR ============================================================================ */
+ /* ======== EVENTS ====(Called from QMI Thread)========================================= */
+ virtual void handleEngineUpEvent();
+ /* ======== UTILITIES ================================================================== */
+ void restartSessions();
+
+ /* ==== ULP ============================================================================ */
+ /* ======== COMMANDS ====(Called from ULP Thread)==================================== */
+ virtual void setUlpProxyCommand(UlpProxyBase* ulp);
+ /* ======== UTILITIES ================================================================== */
+ void setUlpProxy(UlpProxyBase* ulp);
+ inline UlpProxyBase* getUlpProxy() { return mUlpProxy; }
+
+ /* ==== CLIENT ========================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ void addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks);
+ void removeClientCommand(LocationAPI* client);
+ void requestCapabilitiesCommand(LocationAPI* client);
+ /* ======== UTILITIES ================================================================== */
+ void saveClient(LocationAPI* client, const LocationCallbacks& callbacks);
+ void eraseClient(LocationAPI* client);
+ void updateClientsEventMask();
+ void stopClientSessions(LocationAPI* client);
+ LocationCallbacks getClientCallbacks(LocationAPI* client);
+
+ /* ==== TRACKING ======================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ uint32_t startTrackingCommand(LocationAPI* client, LocationOptions& options);
+ void updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, LocationOptions& options);
+ void stopTrackingCommand(LocationAPI* client, uint32_t id);
+ /* ======================(Called from ULP Thread)======================================= */
+ virtual void setPositionModeCommand(LocPosMode& locPosMode);
+ virtual void startTrackingCommand();
+ virtual void stopTrackingCommand();
+ virtual void getZppCommand();
+ /* ======== RESPONSES ================================================================== */
+ void reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId);
+ /* ======== UTILITIES ================================================================== */
+ bool hasTrackingCallback(LocationAPI* client);
+ bool hasMeasurementsCallback(LocationAPI* client);
+ bool isTrackingSession(LocationAPI* client, uint32_t sessionId);
+ void saveTrackingSession(LocationAPI* client, uint32_t sessionId,
+ const LocationOptions& options);
+ void eraseTrackingSession(LocationAPI* client, uint32_t sessionId);
+ void setUlpPositionMode(const LocPosMode& mode) { mUlpPositionMode = mode; }
+ LocPosMode& getUlpPositionMode() { return mUlpPositionMode; }
+ void setSuplMode(GnssSuplMode mode) { mSuplMode = mode; }
+ LocationError startTrackingMultiplex(const LocationOptions& options);
+ LocationError startTracking(const LocationOptions& options);
+ LocationError stopTrackingMultiplex(LocationAPI* client, uint32_t id);
+ LocationError stopTracking();
+
+ /* ==== NI ============================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ void gnssNiResponseCommand(LocationAPI* client, uint32_t id, GnssNiResponse response);
+ /* ======================(Called from NI Thread)======================================== */
+ void gnssNiResponseCommand(GnssNiResponse response, void* rawRequest);
+ /* ======== UTILITIES ================================================================== */
+ bool hasNiNotifyCallback(LocationAPI* client);
+ NiData& getNiData() { return mNiData; }
+
+ /* ==== CONTROL ======================================================================== */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ uint32_t enableCommand(LocationTechnologyType techType);
+ void disableCommand(uint32_t id);
+ void setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks);
+ void readConfigCommand();
+ void setConfigCommand();
+ uint32_t* gnssUpdateConfigCommand(GnssConfig config);
+ uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data);
+
+ void initAgpsCommand(void* statusV4Cb);
+ void dataConnOpenCommand(
+ AGpsExtType agpsType,
+ const char* apnName, int apnLen, LocApnIpType ipType);
+ void dataConnClosedCommand(AGpsExtType agpsType);
+ void dataConnFailedCommand(AGpsExtType agpsType);
+
+ /* ======== RESPONSES ================================================================== */
+ void reportResponse(LocationError err, uint32_t sessionId);
+ void reportResponse(size_t count, LocationError* errs, uint32_t* ids);
+ /* ======== UTILITIES ================================================================== */
+ LocationControlCallbacks& getControlCallbacks() { return mControlCallbacks; }
+ void setControlCallbacks(const LocationControlCallbacks& controlCallbacks)
+ { mControlCallbacks = controlCallbacks; }
+ void setPowerVoteId(uint32_t id) { mPowerVoteId = id; }
+ uint32_t getPowerVoteId() { return mPowerVoteId; }
+ bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress);
+
+ /* ==== REPORTS ======================================================================== */
+ /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */
+ virtual void reportPositionEvent(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask,
+ bool fromUlp=false);
+ virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false);
+ virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false);
+ virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data);
+ virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurementsNotify);
+ virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet);
+ virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);
+
+ virtual bool requestATL(int connHandle, LocAGpsType agps_type);
+ virtual bool releaseATL(int connHandle);
+ virtual bool requestSuplES(int connHandle);
+ virtual bool reportDataCallOpened();
+ virtual bool reportDataCallClosed();
+
+ /* ======== UTILITIES ================================================================= */
+ void reportPosition(const UlpLocation &ulpLocation,
+ const GpsLocationExtended &locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask);
+ void reportSv(GnssSvNotification& svNotify);
+ void reportNmea(const char* nmea, size_t length);
+ bool requestNiNotify(const GnssNiNotification& notify, const void* data);
+ void reportGnssMeasurementData(const GnssMeasurementsNotification& measurementsNotify);
+
+ /*==== NMEA Generation =============================================================== */
+ /*======== SVS ======================================================================= */
+ void generateNmea(const GnssSvNotification& svNotify);
+ void generateNmeaGSV(const GnssSvNotification& svNotify,
+ NmeaSvMeta& svMeta, char* sentence, size_t size);
+ /*======== POSITION ================================================================== */
+ void generateNmea(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended);
+ void generateNmeaBlank();
+ uint8_t generateNmeaGSA(const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, char* sentence, size_t size);
+ void generateNmeaVTG(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, char* sentence, size_t size);
+ void generateNmeaRMC(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, tm& utcTime, char* sentence, size_t size);
+ void generateNmeaGGA(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ NmeaSvMeta& svMeta, tm& utcTime, uint32_t svUsedCount,
+ char* sentence, size_t size);
+ /*======== UTILITIES ================================================================*/
+ int nmeaPutChecksum(char *nmea, size_t maxSize);
+
+ /*==== CONVERSION ===================================================================*/
+ static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock);
+ static GnssConfigGpsLock convertGpsLock(const uint32_t gpsLock);
+ static uint32_t convertSuplVersion(const GnssConfigSuplVersion suplVersion);
+ static GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion);
+ static uint32_t convertLppProfile(const GnssConfigLppProfile lppProfile);
+ static GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile);
+ static uint32_t convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl);
+ static uint32_t convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices);
+ static uint32_t convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask);
+ static GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask);
+ static uint32_t convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask);
+ static GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask);
+ static uint32_t convertAGloProt(const GnssConfigAGlonassPositionProtocolMask);
+ static uint32_t convertSuplMode(const GnssConfigSuplModeMask suplModeMask);
+
+ void injectLocationCommand(double latitude, double longitude, float accuracy);
+ void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty);
+
+};
+
+#endif //GNSS_ADAPTER_H
diff --git a/msm8998/gnss/location_gnss.cpp b/msm8998/gnss/location_gnss.cpp
new file mode 100644
index 0000000..0995f4b
--- /dev/null
+++ b/msm8998/gnss/location_gnss.cpp
@@ -0,0 +1,241 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "GnssAdapter.h"
+#include "location_interface.h"
+
+static GnssAdapter* gGnssAdapter = NULL;
+
+static void initialize();
+static void deinitialize();
+
+static void addClient(LocationAPI* client, const LocationCallbacks& callbacks);
+static void removeClient(LocationAPI* client);
+static void requestCapabilities(LocationAPI* client);
+
+static uint32_t startTracking(LocationAPI* client, LocationOptions& options);
+static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options);
+static void stopTracking(LocationAPI* client, uint32_t id);
+
+static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response);
+static uint32_t gnssDeleteAidingData(GnssAidingData& data);
+
+static void setControlCallbacks(LocationControlCallbacks& controlCallbacks);
+static uint32_t enable(LocationTechnologyType techType);
+static void disable(uint32_t id);
+static uint32_t* gnssUpdateConfig(GnssConfig config);
+
+static void injectLocation(double latitude, double longitude, float accuracy);
+static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty);
+
+static void agpsInit(void* statusV4Cb);
+static void agpsDataConnOpen(AGpsExtType agpsType, const char* apnName, int apnLen, int ipType);
+static void agpsDataConnClosed(AGpsExtType agpsType);
+static void agpsDataConnFailed(AGpsExtType agpsType);
+
+static const GnssInterface gGnssInterface = {
+ sizeof(GnssInterface),
+ initialize,
+ deinitialize,
+ addClient,
+ removeClient,
+ requestCapabilities,
+ startTracking,
+ updateTrackingOptions,
+ stopTracking,
+ gnssNiResponse,
+ setControlCallbacks,
+ enable,
+ disable,
+ gnssUpdateConfig,
+ gnssDeleteAidingData,
+ injectLocation,
+ injectTime,
+ agpsInit,
+ agpsDataConnOpen,
+ agpsDataConnClosed,
+ agpsDataConnFailed
+};
+
+#ifndef DEBUG_X86
+extern "C" const GnssInterface* getGnssInterface()
+#else
+const GnssInterface* getGnssInterface()
+#endif // DEBUG_X86
+{
+ return &gGnssInterface;
+}
+
+static void initialize()
+{
+ if (NULL == gGnssAdapter) {
+ gGnssAdapter = new GnssAdapter();
+ }
+}
+
+static void deinitialize()
+{
+ if (NULL != gGnssAdapter) {
+ delete gGnssAdapter;
+ gGnssAdapter = NULL;
+ }
+}
+
+static void addClient(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->addClientCommand(client, callbacks);
+ }
+}
+
+static void removeClient(LocationAPI* client)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->removeClientCommand(client);
+ }
+}
+
+static void requestCapabilities(LocationAPI* client)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->requestCapabilitiesCommand(client);
+ }
+}
+
+static uint32_t startTracking(LocationAPI* client, LocationOptions& options)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->startTrackingCommand(client, options);
+ } else {
+ return 0;
+ }
+}
+
+static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->updateTrackingOptionsCommand(client, id, options);
+ }
+}
+
+static void stopTracking(LocationAPI* client, uint32_t id)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->stopTrackingCommand(client, id);
+ }
+}
+
+static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->gnssNiResponseCommand(client, id, response);
+ }
+}
+
+static void setControlCallbacks(LocationControlCallbacks& controlCallbacks)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->setControlCallbacksCommand(controlCallbacks);
+ }
+}
+
+static uint32_t enable(LocationTechnologyType techType)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->enableCommand(techType);
+ } else {
+ return 0;
+ }
+}
+
+static void disable(uint32_t id)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->disableCommand(id);
+ }
+}
+
+static uint32_t* gnssUpdateConfig(GnssConfig config)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->gnssUpdateConfigCommand(config);
+ } else {
+ return NULL;
+ }
+}
+
+static uint32_t gnssDeleteAidingData(GnssAidingData& data)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->gnssDeleteAidingDataCommand(data);
+ } else {
+ return NULL;
+ }
+}
+
+static void injectLocation(double latitude, double longitude, float accuracy)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->injectLocationCommand(latitude, longitude, accuracy);
+ }
+}
+
+static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->injectTimeCommand(time, timeReference, uncertainty);
+ }
+}
+
+static void agpsInit(void* statusV4Cb) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->initAgpsCommand(statusV4Cb);
+ }
+}
+static void agpsDataConnOpen(
+ AGpsExtType agpsType, const char* apnName, int apnLen, int ipType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnOpenCommand(
+ agpsType, apnName, apnLen, ipType);
+ }
+}
+static void agpsDataConnClosed(AGpsExtType agpsType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnClosedCommand(agpsType);
+ }
+}
+static void agpsDataConnFailed(AGpsExtType agpsType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnFailedCommand(agpsType);
+ }
+}
diff --git a/msm8998/loc_api/Android.mk b/msm8998/loc_api/Android.mk
deleted file mode 100644
index 743b386..0000000
--- a/msm8998/loc_api/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
-
-LOCAL_PATH := $(call my-dir)
-
-# add RPC dirs if RPC is available
-ifneq ($(TARGET_NO_RPC),true)
-
-GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api-rpc-50001/
-
-endif #TARGET_NO_RPC
-
-GPS_DIR_LIST += $(LOCAL_PATH)/libloc_api_50001/
-
-#call the subfolders
-include $(addsuffix Android.mk, $(GPS_DIR_LIST))
-
-endif#BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/msm8998/loc_api/Makefile.am b/msm8998/loc_api/Makefile.am
deleted file mode 100644
index d9ae87a..0000000
--- a/msm8998/loc_api/Makefile.am
+++ /dev/null
@@ -1,120 +0,0 @@
-AM_CFLAGS = \
- -I./ \
- -I../core \
- -I./libloc_api_50001 \
- -I../utils \
- $(LOCPLA_CFLAGS) \
- -fno-short-enums \
- -D__func__=__PRETTY_FUNCTION__ \
- -DTARGET_USES_QCOM_BSP \
- -std=c++11
-
-AM_CPPFLAGS = \
- -std=c++11
-
-libloc_eng_so_la_h_sources = \
- loc_eng_dmn_conn_glue_msg.h \
- loc_eng_dmn_conn_glue_pipe.h \
- loc_eng_dmn_conn.h \
- loc_eng_dmn_conn_handler.h \
- loc_eng_dmn_conn_thread_helper.h
-
-libloc_eng_so_la_SOURCES = \
- libloc_api_50001/loc.cpp \
- libloc_api_50001/loc_eng.cpp \
- libloc_api_50001/loc_eng_agps.cpp \
- libloc_api_50001/loc_eng_xtra.cpp \
- libloc_api_50001/loc_eng_ni.cpp \
- libloc_api_50001/loc_eng_log.cpp \
- libloc_api_50001/loc_eng_nmea.cpp \
- libloc_api_50001/LocEngAdapter.cpp \
- libloc_api_50001/loc_eng_dmn_conn.cpp \
- libloc_api_50001/loc_eng_dmn_conn_handler.cpp \
- libloc_api_50001/loc_eng_dmn_conn_thread_helper.c \
- libloc_api_50001/loc_eng_dmn_conn_glue_msg.c \
- libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c
-
-libloc_eng_so_la_SOURCES += libloc_eng_so_la_h_sources
-
-if USE_GLIB
-libloc_eng_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_eng_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_eng_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_eng_so_la_CFLAGS = $(AM_CFLAGS)
-libloc_eng_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_eng_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-
-libloc_eng_so_la_LIBADD = -lstdc++ -ldl -llog $(LOCPLA_LIBS) ../utils/libgps_utils_so.la ../core/libloc_core.la
-
-libloc_ds_api_CFLAGS = \
- $(QMIF_CFLAGS) \
- $(QMI_CFLAGS) \
- $(DATA_CFLAGS) \
- -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api
-
-libloc_ds_api_la_SOURCES = \
- $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c
-
-if USE_GLIB
-libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@
-libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
-libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS)
-libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0
-libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
-libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS)
-endif
-
-libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(LOCPLA_LIBS) ../utils/libgps_utils_so.la
-#libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices $(LOCPLA_LIBS) ../utils/libgps_utils_so.la
-
-libloc_api_v02_CFLAGS = \
- $(QMIF_CFLAGS) \
- -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \
- -I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02
-
-libloc_api_v02_la_SOURCES = \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c
-
-if USE_GLIB
-libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@
-libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS)
-libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS)
-endif
-
-libloc_api_v02_la_CXXFLAGS = -std=c++0x
-libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la ../utils/libgps_utils_so.la libloc_ds_api.la
-
-library_include_HEADERS = \
- libloc_api_50001/LocEngAdapter.h \
- libloc_api_50001/loc.h \
- libloc_api_50001/loc_eng.h \
- libloc_api_50001/loc_eng_xtra.h \
- libloc_api_50001/loc_eng_ni.h \
- libloc_api_50001/loc_eng_agps.h \
- libloc_api_50001/loc_eng_msg.h \
- libloc_api_50001/loc_eng_log.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \
- $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h
-
-library_includedir = $(pkgincludedir)
-
-#Create and Install libraries
-lib_LTLIBRARIES = libloc_eng_so.la libloc_ds_api.la libloc_api_v02.la
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/Android.mk b/msm8998/loc_api/libloc_api-rpc-50001/Android.mk
deleted file mode 100644
index 6c5d533..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/Android.mk
+++ /dev/null
@@ -1,3 +0,0 @@
-ifeq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_AMSS_VERSION),50001)
-include $(call all-subdir-makefiles)
-endif
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
deleted file mode 100644
index bb3d924..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Android.mk
+++ /dev/null
@@ -1,60 +0,0 @@
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-RPC_INC:=rpc_inc
-
-source_files:= \
- src/loc_api_rpc_glue.c \
- src/loc_api_sync_call.c \
- src/loc_apicb_appinit.c \
- src/loc_api_fixup.c \
- src/loc_api_log.c \
- src/LocApiRpc.cpp
-
-LOCAL_SRC_FILES:= $(source_files)
-
-LOCAL_CFLAGS:=-fno-short-enums
-LOCAL_CFLAGS+=-DDEBUG -DUSE_QCOM_AUTO_RPC -DUSE_QCOM_AUTO_RPC
-LOCAL_CFLAGS+=$(GPS_FEATURES)
-
-# for loc_api_fixup.c
-LOCAL_CFLAGS+=-DADD_XDR_FLOAT -DADD_XDR_BOOL
-
-LOCAL_SHARED_LIBRARIES:= \
- librpc \
- libutils \
- libcutils \
- libcommondefs \
- libgps.utils \
- libloc_core
-
-LOCAL_STATIC_LIBRARIES := \
- libloc_api_rpcgen
-
-LOCAL_PRELINK_MODULE:= false
-
-LOCAL_C_INCLUDES:= \
- $(LOCAL_PATH) \
- $(LOCAL_PATH)/rpc_inc \
- $(TARGET_OUT_HEADERS)/gps.utils \
- $(TARGET_OUT_HEADERS)/libloc_core \
- $(TARGET_OUT_HEADERS)/loc_api/rpcgen/inc \
- $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc \
- $(TARGET_OUT_HEADERS)/librpc \
- $(TARGET_OUT_HEADERS)/libloc-rpc/rpc_inc \
- $(TOP)/hardware/msm7k/librpc
-
-LOCAL_COPY_HEADERS_TO:= libloc_api-rpc-qc/$(RPC_INC)
-LOCAL_COPY_HEADERS:= \
- $(RPC_INC)/loc_api_rpc_glue.h \
- $(RPC_INC)/loc_api_fixup.h \
- $(RPC_INC)/loc_api_sync_call.h \
- $(RPC_INC)/loc_apicb_appinit.h \
- $(RPC_INC)/LocApiRpc.h
-
-LOCAL_MODULE:= libloc_api-rpc-qc
-LOCAL_MODULE_OWNER := qcom
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am
deleted file mode 100644
index 7f2e9d3..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/Makefile.am
+++ /dev/null
@@ -1,46 +0,0 @@
-AM_CFLAGS = \
- -I../../../utils \
- -I../../../platform_lib_abstractions \
- -I./rpc_inc \
- -I../libloc_api-rpc-stub/inc \
- -I../../libloc_api_50001 \
- $(MSM7K_CFLAGS) \
- -DUSE_QCOM_AUTO_RPC
-
-requiredlibs = \
- ../../../utils/libgps_utils_so.la \
- $(MSM7K_LIBS)
-
-h_sources = \
- rpc_inc/loc_api_rpc_glue.h \
- rpc_inc/loc_api_fixup.h \
- rpc_inc/loc_api_sync_call.h \
- rpc_inc/loc_apicb_appinit.h \
-
-c_sources = \
- src/loc_api_rpc_glue.c \
- src/loc_api_sync_call.c \
- src/loc_apicb_appinit.c \
- src/loc_api_fixup.c \
- src/loc_api_log.c \
- src/LocApiRpcAdapter.cpp \
-
-
-library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc
-library_include_HEADERS = $(h_sources)
-libloc_api_rpc_qc_la_SOURCES = $(c_sources) $(h_sources)
-
-if USE_GLIB
-libloc_api_rpc_qc_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_api_rpc_qc_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_api_rpc_qc_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_api_rpc_qc_la_CFLAGS = $(AM_CFLAGS)
-libloc_api_rpc_qc_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_api_rpc_qc_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-
-libloc_api_rpc_qc_la_LIBADD = $(requiredlibs) -lstdc++
-
-#Create and Install Libraries
-lib_LTLIBRARIES = libloc_api_rpc_qc.la
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
deleted file mode 100644
index b2b4e2a..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/LocApiRpc.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/* Copyright (c) 2011,2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_API_RPC_H
-#define LOC_API_RPC_H
-
-#include <rpc/rpc.h>
-#include <loc_api_rpcgen_common_rpc.h>
-#include <loc_api_rpc_glue.h>
-#include <LocApiBase.h>
-#include <loc_log.h>
-
-using namespace loc_core;
-
-class LocApiRpc : public LocApiBase {
-protected:
- // RPC communication establishment
- rpc_loc_client_handle_type client_handle;
-
-private:
- int dataEnableLastSet;
- char apnLastSet[MAX_APN_LEN];
-
- static const LOC_API_ADAPTER_EVENT_MASK_T maskAll;
- static const rpc_loc_event_mask_type locBits[];
- static rpc_loc_event_mask_type convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask);
- static rpc_loc_lock_e_type convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask);
- static enum loc_api_adapter_err convertErr(int rpcErr);
- static LocGpsNiEncodingType convertNiEncodingType(int loc_encoding);
- static int NIEventFillVerfiyType(LocGpsNiNotification ¬if,
- rpc_loc_ni_notify_verify_e_type notif_priv);
-
- void reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr);
- void reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr);
- void reportStatus(const rpc_loc_status_event_s_type *status_report_ptr);
- void reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr);
- void ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr);
- void NIEvent(const rpc_loc_ni_event_s_type *ni_req_ptr);
-
-protected:
- virtual enum loc_api_adapter_err
- open(LOC_API_ADAPTER_EVENT_MASK_T mask);
- virtual enum loc_api_adapter_err
- close();
- LocApiRpc(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask);
-
-public:
- static LocApiRpc* createLocApiRpc(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask);
- ~LocApiRpc();
-
- virtual int locEventCB(rpc_loc_client_handle_type client_handle,
- rpc_loc_event_mask_type loc_event,
- const rpc_loc_event_payload_u_type* loc_event_payload);
-
- void locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event);
-
- // RPC adapter interface implementations
- virtual enum loc_api_adapter_err
- startFix(const LocPosMode& posMode);
- virtual enum loc_api_adapter_err
- stopFix();
- virtual enum loc_api_adapter_err
- setPositionMode(const LocPosMode& mode);
- inline virtual enum loc_api_adapter_err
- enableData(int enable) { return enableData(enable, false); }
- virtual enum loc_api_adapter_err
- enableData(int enable, boolean force);
- virtual enum loc_api_adapter_err
- setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty);
- virtual enum loc_api_adapter_err
- injectPosition(double latitude, double longitude, float accuracy);
- virtual enum loc_api_adapter_err
- deleteAidingData(LocGpsAidingData f);
- virtual enum loc_api_adapter_err
- informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData);
- inline virtual enum loc_api_adapter_err
- setAPN(char* apn, int len) { return setAPN(apn, len, false); }
- virtual enum loc_api_adapter_err
- setAPN(char* apn, int len, boolean force);
- virtual enum loc_api_adapter_err
- setServer(const char* url, int len);
- virtual enum loc_api_adapter_err
- setServer(unsigned int ip, int port, LocServerType type);
- virtual enum loc_api_adapter_err
- setXtraData(char* data, int length);
- virtual enum loc_api_adapter_err
- requestXtraServer();
- virtual enum loc_api_adapter_err
- atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, LocAGpsType agpsType);
- virtual enum loc_api_adapter_err
- atlCloseStatus(int handle, int is_succ);
- virtual enum loc_api_adapter_err
- setSUPLVersion(uint32_t version);
- virtual void setInSession(bool inSession);
-
- /*Values for lock
- 1 = Do not lock any position sessions
- 2 = Lock MI position sessions
- 3 = Lock MT position sessions
- 4 = Lock all position sessions
- */
- virtual int setGpsLock(LOC_GPS_LOCK_MASK lock);
- /*
- Returns
- Current value of GPS Lock on success
- -1 on failure
- */
- virtual int getGpsLock(void);
-};
-
-extern "C" LocApiBase* getLocApi(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask,
- ContextBase *context);
-
-#endif //LOC_API_RPC_H
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h
deleted file mode 100644
index 49a6d0b..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/debug.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef DEBUG_H
-#define DEBUG_H
-
-#include <stdio.h>
-
-#define LOG_TAG "LocSvc_rpc"
-#include <utils/Log.h>
-
-#define PRINT(x...) do { \
- fprintf(stdout, "%s(%d) ", __FUNCTION__, __LINE__); \
- fprintf(stdout, ##x); \
- ALOGD(x); \
- } while(0)
-
-#ifdef DEBUG
-#define D PRINT
-#else
-#define D(x...) do { } while(0)
-#endif
-
-#ifdef VERBOSE
-#define V PRINT
-#else
-#define V(x...) do { } while(0)
-#endif
-
-#define E(x...) do { \
- fprintf(stderr, "%s(%d) ", __FUNCTION__, __LINE__); \
- fprintf(stderr, ##x); \
- ALOGE(x); \
- } while(0)
-
-#define FAILIF(cond, msg...) do { \
- if (__builtin_expect (cond, 0)) { \
- fprintf(stderr, "%s:%s:(%d): ", __FILE__, __FUNCTION__, __LINE__); \
- fprintf(stderr, ##msg); \
- ALOGE(##msg); \
- } \
- } while(0)
-
-#endif/*DEBUG_H*/
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h
deleted file mode 100644
index c483b4a..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_fixup.h
+++ /dev/null
@@ -1,226 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOC_API_FIXUP_H
-#define LOC_API_FIXUP_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#ifndef NULLPROC
-#define NULLPROC 0
-#endif /* NULLPROC */
-
-#ifdef ADD_XDR_FLOAT
-
-extern bool_t xdr_float (XDR *__xdrs, float *__fp);
-extern bool_t xdr_double (XDR *__xdrs, double *__dp);
-
-#endif /* ADD_XDR_FLOAT */
-
-#ifdef ADD_XDR_BOOL
-extern bool_t xdr_bool(XDR *__xdrs, int *__bp);
-#endif /* ADD_XDR_BOOL */
-
-#define RPC_LOC_API_MAJOR_VERSION_NUMBER 1
-#define RPC_LOC_API_MINOR_VERSION_NUMBER 0
-
-// Return value for loc_open in case of failure.
-#define RPC_LOC_CLIENT_HANDLE_INVALID -1
-
-// Return value of loc api calls for loc_close, loc_start_fix, loc_stop_fix and loc_ioctl
-// These are also the status for the ioctl callback
-#define RPC_LOC_API_SUCCESS 0
-#define RPC_LOC_API_GENERAL_FAILURE 1
-#define RPC_LOC_API_UNSUPPORTED 2
-#define RPC_LOC_API_INVALID_HANDLE 4
-#define RPC_LOC_API_INVALID_PARAMETER 5
-#define RPC_LOC_API_ENGINE_BUSY 6
-#define RPC_LOC_API_PHONE_OFFLINE 7
-#define RPC_LOC_API_TIMEOUT 8
-
-// Special return value for loc api calls in case of RPC failure
-#define RPC_LOC_API_RPC_FAILURE (-1234)
-// Special return value for modem restart incurred RPC failure
-#define RPC_LOC_API_RPC_MODEM_RESTART (-1235)
-
-#define RPC_LOC_API_MAX_SV_COUNT 80
-#define RPC_LOC_API_MAX_NMEA_STRING_LENGTH 1200
-
-// Maximum server address that will be used in location API
-#define RPC_LOC_API_MAX_SERVER_ADDR_LENGTH 256
-#define RPC_LOC_API_MAX_NUM_PREDICTED_ORBITS_SERVERS 3
-#define RPC_LOC_API_MAX_NUM_NTP_SERVERS 3
-
-#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001 // Position report comes in loc_parsed_position_s_type
-#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002 // Satellite in view report
-#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004 // NMEA report at 1HZ rate
-#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008 // NMEA report at position report rate
-#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010 // NI notification/verification request
-#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020 // Assistance data, eg: time, predicted orbits request
-#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040 // Request for location server
-#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080 // Callback report for loc_ioctl
-#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100 // Misc status report: eg, engine state
-
-#define RPC_LOC_POS_VALID_SESSION_STATUS 0x00000001
-#define RPC_LOC_POS_VALID_TIMESTAMP_CALENDAR 0x00000002
-#define RPC_LOC_POS_VALID_TIMESTAMP_UTC 0x00000004
-#define RPC_LOC_POS_VALID_LEAP_SECONDS 0x00000008
-#define RPC_LOC_POS_VALID_TIME_UNC 0x00000010
-#define RPC_LOC_POS_VALID_LATITUDE 0x00000020
-#define RPC_LOC_POS_VALID_LONGITUDE 0x00000040
-#define RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000080
-#define RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000100
-#define RPC_LOC_POS_VALID_SPEED_HORIZONTAL 0x00000200
-#define RPC_LOC_POS_VALID_SPEED_VERTICAL 0x00000400
-#define RPC_LOC_POS_VALID_HEADING 0x00000800
-#define RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR 0x00001000
-#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MAJ 0x00002000
-#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_SEMI_MIN 0x00004000
-#define RPC_LOC_POS_VALID_HOR_UNC_ELLI_ORIENT_AZIMUTH 0x00008000
-#define RPC_LOC_POS_VALID_VERTICAL_UNC 0x00010000
-#define RPC_LOC_POS_VALID_SPEED_UNC 0x00020000
-#define RPC_LOC_POS_VALID_HEADING_UNC 0x00040000
-#define RPC_LOC_POS_VALID_CONFIDENCE_HORIZONTAL 0x00080000
-#define RPC_LOC_POS_VALID_CONFIDENCE_VERTICAL 0x00100000
-#define RPC_LOC_POS_VALID_MAGNETIC_VARIATION 0x00200000
-#define RPC_LOC_POS_VALID_TECHNOLOGY_MASK 0x00400000
-
-#define RPC_LOC_POS_TECH_SATELLITE 0x00000001
-#define RPC_LOC_POS_TECH_CELLID 0x00000002
-#define RPC_LOC_POS_TECH_WIFI 0x00000004
-
-#define RPC_LOC_SV_INFO_VALID_SYSTEM 0x00000001
-#define RPC_LOC_SV_INFO_VALID_PRN 0x00000002
-#define RPC_LOC_SV_INFO_VALID_HEALTH_STATUS 0x00000004
-#define RPC_LOC_SV_INFO_VALID_PROCESS_STATUS 0x00000008
-#define RPC_LOC_SV_INFO_VALID_HAS_EPH 0x00000010
-#define RPC_LOC_SV_INFO_VALID_HAS_ALM 0x00000020
-#define RPC_LOC_SV_INFO_VALID_ELEVATION 0x00000040
-#define RPC_LOC_SV_INFO_VALID_AZIMUTH 0x00000080
-#define RPC_LOC_SV_INFO_VALID_SNR 0x00000100
-
-#define RPC_LOC_GNSS_INFO_VALID_POS_DOP 0x00000001
-#define RPC_LOC_GNSS_INFO_VALID_HOR_DOP 0x00000002
-#define RPC_LOC_GNSS_INFO_VALID_VERT_DOP 0x00000004
-#define RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED 0x00000008
-#define RPC_LOC_GNSS_INFO_VALID_SV_COUNT 0x00000010
-#define RPC_LOC_GNSS_INFO_VALID_SV_LIST 0x00000020
-
-#define RPC_LOC_NI_MAX_REQUESTOR_ID_LENGTH 200
-#define RPC_LOC_NI_SUPL_HASH_LENGTH 8
-#define RPC_LOC_NI_SUPL_SLP_SESSION_ID_BYTE_LENGTH 4
-#define RPC_LOC_NI_MAX_CLIENT_NAME_LENGTH 64
-#define RPC_LOC_NI_MAX_EXT_CLIENT_ADDRESS 20
-#define RPC_LOC_NI_CODEWORD_LENGTH 20
-
-#define RPC_LOC_NI_SUPL_QOP_VALID 0x01
-#define RPC_LOC_NI_SUPL_QOP_VERACC_VALID 0x02
-#define RPC_LOC_NI_SUPL_QOP_MAXAGE_VALID 0x04
-#define RPC_LOC_NI_SUPL_QOP_DELAY_VALID 0x08
-
-#define RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE 0x00000001
-#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE 0x00000002
-#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY 0x00000004
-#define RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME 0x00000008
-#define RPC_LOC_FIX_CRIT_VALID_INTERMEDIATE_POS_REPORT_ENABLED 0x00000010
-#define RPC_LOC_FIX_CRIT_VALID_NOTIFY_TYPE 0x00000020
-#define RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL 0x00000040
-#define RPC_LOC_FIX_CRIT_VALID_MIN_DISTANCE 0x00000080
-#define RPC_LOC_FIX_CRIT_VALID_MIN_DIST_SAMPLE_INTERVAL 0x00000100
-
-#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_UTC 0x00000001
-#define RPC_LOC_ASSIST_POS_VALID_LATITUDE 0x00000002
-#define RPC_LOC_ASSIST_POS_VALID_LONGITUDE 0x00000004
-#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_ELLIPSOID 0x00000008
-#define RPC_LOC_ASSIST_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL 0x00000010
-#define RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR 0x00000020
-#define RPC_LOC_ASSIST_POS_VALID_VERT_UNC 0x00000040
-#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL 0x00000080
-#define RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_VERTICAL 0x00000100
-#define RPC_LOC_ASSIST_POS_VALID_TIMESTAMP_AGE 0x00000200
-
-#define RPC_LOC_ASSIST_DATA_ALL 0xFFFFFFFF
-
-#define RPC_LOC_NMEA_MASK_ALL 0xffff
-#define RPC_LOC_NMEA_MASK_GGA 0x0001
-#define RPC_LOC_NMEA_MASK_RMC 0x0002
-#define RPC_LOC_NMEA_MASK_GSV 0x0004
-#define RPC_LOC_NMEA_MASK_GSA 0x0008
-#define RPC_LOC_NMEA_MASK_VTG 0x0010
-
-/* EFS data access */
-#define RPC_LOC_EFS_MAX_PATH_LEN_BYTES 64 /* Max file name length in bytes that can be written*/
-#define RPC_LOC_EFS_MAX_FILE_LEN_BYTES 2000 /* Max file size in bytes that can be written */
-
-/* WIPER valid information flag in log report */
-#define RPC_LOC_WIPER_LOG_TIME_VALID 0x01
-#define RPC_LOC_WIPER_LOG_POS_VALID 0x02
-#define RPC_LOC_WIPER_LOG_AP_SET_VALID 0x04
-
-/* General WIPER defines */
-#define RPC_LOC_WIPER_MAC_ADDR_LENGTH 6 // Do not change this number since it affects RPC and log packet sizes
-#define RPC_LOC_WIPER_MAX_REPORTED_APS_PER_LOG_MSG 50 // Do not change this number since it affects RPC and log packet sizes
-
-/* WIPER AP Qualifier */
-#define RPC_LOC_WIPER_AP_QUALIFIER_BEING_USED 0x1 /* AP is being used by WPS */
-#define RPC_LOC_WIPER_AP_QUALIFIER_HIDDEN_SSID 0x2 /* AP does not broadcast SSID */
-#define RPC_LOC_WIPER_AP_QUALIFIER_PRIVATE 0x4 /* AP has encryption turned on */
-#define RPC_LOC_WIPER_AP_QUALIFIER_INFRASTRUCTURE_MODE 0x8 /* AP is in infrastructure mode and not in ad-hoc/unknown mode */
-
-/* flags for notification */
-#define RPC_LOC_NI_CLIENT_NAME_PRESENT 0x0001
-#define RPC_LOC_NI_CLIENT_EXTADDR_PRESENT 0x0002
-#define RPC_LOC_NI_DEF_LOCATION_TYPE_PRESENT 0x0010
-#define RPC_LOC_NI_REQUESTOR_ID_PRESENT 0x0020
-#define RPC_LOC_NI_CODEWORD_PRESENT 0x0040
-#define RPC_LOC_NI_SERVICE_TYPE_ID_PRESENT 0x0080
-#define RPC_LOC_NI_ENCODING_TYPE_PRESENT 0x0100
-
-/* below are for RPC_LOC_IOCTL_SET_LBS_APN_PROFILE data */
-/* values for apn_profiles[0].srv_system_type */
-#define LOC_APN_PROFILE_SRV_SYS_CDMA 0x01
-#define LOC_APN_PROFILE_SRV_SYS_HDR 0x02
-#define LOC_APN_PROFILE_SRV_SYS_GSM 0x04
-#define LOC_APN_PROFILE_SRV_SYS_WCDMA 0x08
-#define LOC_APN_PROFILE_SRV_SYS_LTE 0x10
-#define LOC_APN_PROFILE_SRV_SYS_MAX 0x1F
-/* values for apn_profiles[0].pdp_type */
-#define LOC_APN_PROFILE_PDN_TYPE_IPV4 0x01
-#define LOC_APN_PROFILE_PDN_TYPE_IPV6 0x02
-#define LOC_APN_PROFILE_PDN_TYPE_IPV4V6 0x03
-#define LOC_APN_PROFILE_PDN_TYPE_PPP 0x04
-#define LOC_APN_PROFILE_PDN_TYPE_MAX 0x04
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LOC_API_FIXUP_H */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h
deleted file mode 100644
index f037428..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_log.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (c) 2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_API_LOG_H
-#define LOC_API_LOG_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include <ctype.h>
-#include "loc_api_rpcgen_common_rpc.h"
-
-extern int loc_callback_log(
- rpc_loc_event_mask_type loc_event, /* event mask */
- const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
-);
-
-extern const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open);
-extern const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask);
-extern const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type);
-extern const char* loc_get_ioctl_status_name(uint32 status);
-extern const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status);
-extern const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state);
-extern const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state);
-extern const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LOC_API_LOG_H */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h
deleted file mode 100644
index 6df33ae..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_rpc_glue.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOC_API_RPC_GLUE_H
-#define LOC_API_RPC_GLUE_H
-
-/* Include RPC headers */
-#ifdef USE_LOCAL_RPC
-#include "rpc_inc/loc_api_common.h"
-#include "rpc_inc/loc_api.h"
-#include "rpc_inc/loc_api_cb.h"
-#endif
-
-#ifdef USE_QCOM_AUTO_RPC
-#include "loc_api_rpcgen_rpc.h"
-#include "loc_api_rpcgen_common_rpc.h"
-#include "loc_api_rpcgen_cb_rpc.h"
-#endif
-
-/* Boolean */
-/* Other data types in comdef.h are defined in rpc stubs, so fix it here */
-typedef unsigned char boolean;
-#define TRUE 1
-#define FALSE 0
-
-#include "loc_api_fixup.h"
-#include "loc_api_sync_call.h"
-#include <rpc/clnt.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-extern int loc_api_glue_init(void);
-extern int loc_api_null(void);
-
-typedef int32 (loc_event_cb_f_type)(
- void* userData,
- rpc_loc_client_handle_type loc_handle, /* handle of the client */
- rpc_loc_event_mask_type loc_event, /* event mask */
- const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
-);
-
-typedef void (loc_reset_notif_cb_f_type)(
- void* userData,
- CLIENT* clnt,
- enum rpc_reset_event event
-);
-
-extern rpc_loc_client_handle_type loc_open(
- rpc_loc_event_mask_type event_reg_mask,
- loc_event_cb_f_type *event_callback,
- loc_reset_notif_cb_f_type *rpc_global_cb,
- void* userData
-);
-
-extern int32 loc_close
-(
- rpc_loc_client_handle_type handle
-);
-
-extern void loc_clear
-(
- rpc_loc_client_handle_type handle
-);
-
-extern int32 loc_start_fix
-(
- rpc_loc_client_handle_type handle
-);
-
-extern int32 loc_stop_fix
-(
- rpc_loc_client_handle_type handle
-);
-
-extern int32 loc_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data
-);
-
-extern int loc_eng_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
- uint32 timeout_msec,
- rpc_loc_ioctl_callback_s_type *cb_data_ptr
-);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LOC_API_RPC_GLUE_H */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h
deleted file mode 100644
index 43208bd..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_api_sync_call.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOC_API_CB_SYNC_H
-#define LOC_API_CB_SYNC_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-#include "loc_api_rpc_glue.h"
-#define LOC_SYNC_CALL_SLOTS_MAX 8
-
-typedef struct {
- pthread_mutex_t lock;
-
- /* Client ID */
- rpc_loc_client_handle_type loc_handle;
-
- /* Callback waiting conditional variable */
- pthread_cond_t loc_cb_arrived_cond;
-
- /* Callback waiting data block, protected by loc_cb_data_mutex */
- boolean in_use;
- boolean signal_sent;
- boolean not_available;
- rpc_loc_event_mask_type loc_cb_wait_event_mask; /* event to wait for */
- rpc_loc_ioctl_e_type ioctl_type; /* ioctl to wait for */
- rpc_loc_event_payload_u_type loc_cb_received_payload; /* received payload */
- rpc_loc_event_mask_type loc_cb_received_event_mask; /* received event */
-} loc_sync_call_slot_s_type;
-
-typedef struct {
- int num_of_slots;
- loc_sync_call_slot_s_type slots[LOC_SYNC_CALL_SLOTS_MAX];
-} loc_sync_call_slot_array_s_type;
-
-/* Init function */
-void loc_api_sync_call_init();
-
-/* Destroy function */
-void loc_api_sync_call_destroy();
-
-/* Process Loc API callbacks to wake up blocked user threads */
-void loc_api_callback_process_sync_call(
- rpc_loc_client_handle_type loc_handle, /* handle of the client */
- rpc_loc_event_mask_type loc_event, /* event mask */
- const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
-);
-
-/* Reentrant synchronous IOCTL call, using Loc API return code */
-int loc_api_sync_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
- uint32 timeout_msec,
- rpc_loc_ioctl_callback_s_type *cb_data_ptr
-);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LOC_API_CB_SYNC_H */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h
deleted file mode 100644
index ba41d08..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/rpc_inc/loc_apicb_appinit.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOC_APICB_APPINIT_H
-#define LOC_APICB_APPINIT_H
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
- /* Initialization function for callbacks */
-extern int loc_apicb_app_init();
-extern void loc_apicb_app_deinit();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* LOC_APICB_APPINIT_H */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
deleted file mode 100644
index f0f84b5..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/LocApiRpc.cpp
+++ /dev/null
@@ -1,1475 +0,0 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_api_rpc"
-
-#include <unistd.h>
-#include <math.h>
-#ifndef USE_GLIB
-#include <utils/SystemClock.h>
-#endif /* USE_GLIB */
-#include <LocApiRpc.h>
-#include <LocAdapterBase.h>
-#include <loc_api_fixup.h>
-#include <loc_api_rpc_glue.h>
-#include <loc_log.h>
-#include <loc_api_log.h>
-#ifdef USE_GLIB
-#include <glib.h>
-#endif
-#include <librpc.h>
-#include <platform_lib_includes.h>
-
-using namespace loc_core;
-
-#define LOC_XTRA_INJECT_DEFAULT_TIMEOUT (3100)
-#define XTRA_BLOCK_SIZE (3072)
-#define LOC_IOCTL_DEFAULT_TIMEOUT 1000 // 1000 milli-seconds
-#define LOC_NI_NOTIF_KEY_ADDRESS "Address"
-
-/*===========================================================================
-FUNCTION loc_event_cb
-
-DESCRIPTION
- This is the callback function registered by loc_open.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int32 loc_event_cb
-(
- void* user,
- rpc_loc_client_handle_type client_handle,
- rpc_loc_event_mask_type loc_event,
- const rpc_loc_event_payload_u_type* loc_event_payload
-)
-{
- MODEM_LOG_CALLFLOW(%s, loc_get_event_name(loc_event));
- loc_callback_log(loc_event, loc_event_payload);
- int32 ret_val = ((LocApiRpc*)user)->locEventCB(client_handle, loc_event, loc_event_payload);
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_rpc_global_cb
-
-DESCRIPTION
- This is the callback function registered by loc_open for RPC global events
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- RPC_LOC_API_SUCCESS
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_rpc_global_cb(void* user, CLIENT* clnt, enum rpc_reset_event event)
-{
- MODEM_LOG_CALLFLOW(%s, loc_get_rpc_reset_event_name(event));
- ((LocApiRpc*)user)->locRpcGlobalCB(clnt, event);
- EXIT_LOG(%p, VOID_RET);
-}
-
-const LOC_API_ADAPTER_EVENT_MASK_T LocApiRpc::maskAll =
- LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
- LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
- LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
- LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
- LOC_API_ADAPTER_BIT_IOCTL_REPORT |
- LOC_API_ADAPTER_BIT_STATUS_REPORT |
- LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
- LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
-
-const rpc_loc_event_mask_type LocApiRpc::locBits[] =
-{
- RPC_LOC_EVENT_PARSED_POSITION_REPORT,
- RPC_LOC_EVENT_SATELLITE_REPORT,
- RPC_LOC_EVENT_NMEA_1HZ_REPORT,
- RPC_LOC_EVENT_NMEA_POSITION_REPORT,
- RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST,
- RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST,
- RPC_LOC_EVENT_LOCATION_SERVER_REQUEST,
- RPC_LOC_EVENT_IOCTL_REPORT,
- RPC_LOC_EVENT_STATUS_REPORT,
- RPC_LOC_EVENT_WPS_NEEDED_REQUEST
-};
-
-LocApiRpc*
-LocApiRpc::createLocApiRpc(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask,
- ContextBase* context)
-{
- if (NULL == msgTask) {
- return NULL;
- }
- return new LocApiRpc(msgTask, exMask, context);
-}
-
-// constructor
-LocApiRpc::LocApiRpc(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask,
- ContextBase* context) :
- LocApiBase(msgTask, exMask, context),
- client_handle(RPC_LOC_CLIENT_HANDLE_INVALID),
- dataEnableLastSet(-1)
-{
- memset(apnLastSet, 0, sizeof(apnLastSet));
- loc_api_glue_init();
-}
-
-LocApiRpc::~LocApiRpc()
-{
- close();
-}
-
-rpc_loc_event_mask_type
-LocApiRpc::convertMask(LOC_API_ADAPTER_EVENT_MASK_T mask)
-{
- rpc_loc_event_mask_type newMask = 0;
-
- for (unsigned int i = 0, bit=1; 0 != mask; i++, bit<<=1) {
- if (mask & bit) {
- newMask |= locBits[i];
- mask ^= bit;
- }
- }
-
- return newMask;
-}
-
-rpc_loc_lock_e_type
-LocApiRpc::convertGpsLockMask(LOC_GPS_LOCK_MASK lockMask)
-{
- if (isGpsLockAll(lockMask))
- return RPC_LOC_LOCK_ALL;
- if (isGpsLockMO(lockMask))
- return RPC_LOC_LOCK_MI;
- if (isGpsLockMT(lockMask))
- return RPC_LOC_LOCK_MT;
- if (isGpsLockNone(lockMask))
- return RPC_LOC_LOCK_NONE;
- return (rpc_loc_lock_e_type)lockMask;
-}
-
-enum loc_api_adapter_err
-LocApiRpc::convertErr(int rpcErr)
-{
- switch(rpcErr)
- {
- case RPC_LOC_API_SUCCESS:
- return LOC_API_ADAPTER_ERR_SUCCESS;
- case RPC_LOC_API_GENERAL_FAILURE:
- return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
- case RPC_LOC_API_UNSUPPORTED:
- return LOC_API_ADAPTER_ERR_UNSUPPORTED;
- case RPC_LOC_API_INVALID_HANDLE:
- return LOC_API_ADAPTER_ERR_INVALID_HANDLE;
- case RPC_LOC_API_INVALID_PARAMETER:
- return LOC_API_ADAPTER_ERR_INVALID_PARAMETER;
- case RPC_LOC_API_ENGINE_BUSY:
- return LOC_API_ADAPTER_ERR_ENGINE_BUSY;
- case RPC_LOC_API_PHONE_OFFLINE:
- return LOC_API_ADAPTER_ERR_PHONE_OFFLINE;
- case RPC_LOC_API_TIMEOUT:
- return LOC_API_ADAPTER_ERR_TIMEOUT;
- case RPC_LOC_API_RPC_MODEM_RESTART:
- return LOC_API_ADAPTER_ERR_ENGINE_DOWN;
- case RPC_LOC_API_RPC_FAILURE:
- return LOC_API_ADAPTER_ERR_FAILURE;
- default:
- return LOC_API_ADAPTER_ERR_UNKNOWN;
- }
-}
-
-void LocApiRpc::locRpcGlobalCB(CLIENT* clnt, enum rpc_reset_event event)
-{
- static rpc_loc_engine_state_e_type last_state = RPC_LOC_ENGINE_STATE_MAX;
-
- switch (event) {
- case RPC_SUBSYSTEM_RESTART_BEGIN:
- if (RPC_LOC_ENGINE_STATE_OFF != last_state) {
- last_state = RPC_LOC_ENGINE_STATE_OFF;
- handleEngineDownEvent();
- }
- break;
- case RPC_SUBSYSTEM_RESTART_END:
- if (RPC_LOC_ENGINE_STATE_ON != last_state) {
- last_state = RPC_LOC_ENGINE_STATE_ON;
- handleEngineUpEvent();
- }
- break;
- }
-}
-
-int32 LocApiRpc::locEventCB(rpc_loc_client_handle_type client_handle,
- rpc_loc_event_mask_type loc_event,
- const rpc_loc_event_payload_u_type* loc_event_payload)
-{
- // Parsed report
- if (loc_event & RPC_LOC_EVENT_PARSED_POSITION_REPORT)
- {
- reportPosition(&loc_event_payload->rpc_loc_event_payload_u_type_u.
- parsed_location_report);
- }
-
- // Satellite report
- if (loc_event & RPC_LOC_EVENT_SATELLITE_REPORT)
- {
- reportSv(&loc_event_payload->rpc_loc_event_payload_u_type_u.gnss_report);
- }
-
- // Status report
- if (loc_event & RPC_LOC_EVENT_STATUS_REPORT)
- {
- reportStatus(&loc_event_payload->rpc_loc_event_payload_u_type_u.status_report);
- }
-
- // NMEA
- if (loc_event & RPC_LOC_EVENT_NMEA_1HZ_REPORT)
- {
- reportNmea(&(loc_event_payload->rpc_loc_event_payload_u_type_u.nmea_report));
- }
- // XTRA support: supports only XTRA download
- if (loc_event & RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST)
- {
- if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
- RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ)
- {
- requestXtraData();
- } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
- RPC_LOC_ASSIST_DATA_TIME_REQ)
- {
- requestTime();
- } else if (loc_event_payload->rpc_loc_event_payload_u_type_u.assist_data_request.event ==
- RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ)
- {
- requestLocation();
- }
- }
-
- // AGPS data request
- if (loc_event & RPC_LOC_EVENT_LOCATION_SERVER_REQUEST)
- {
- ATLEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u.
- loc_server_request);
- }
-
- // NI notify request
- if (loc_event & RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST)
- {
- NIEvent(&loc_event_payload->rpc_loc_event_payload_u_type_u.ni_request);
- }
-
- return RPC_LOC_API_SUCCESS;//We simply want to return sucess here as we do not want to
- // cause any issues in RPC thread context
-}
-
-enum loc_api_adapter_err
-LocApiRpc::open(LOC_API_ADAPTER_EVENT_MASK_T mask)
-{
- enum loc_api_adapter_err ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
-
- // RPC does not dynamically update the event mask. And in the
- // case of RPC, all we support are positioning (gps + agps)
- // masks anyways, so we simply mask all of them on always.
- // After doing so the first time in a power cycle, we know there
- // will the following if condition will never be true any more.
- mask = maskAll;
-
- if (mask != mMask) {
- if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) {
- close();
- }
-
- mMask = mask;
- // it is important to cap the mask here, because not all LocApi's
- // can enable the same bits, e.g. foreground and bckground.
- client_handle = loc_open(convertMask(mask),
- loc_event_cb,
- loc_rpc_global_cb, this);
-
- if (client_handle < 0) {
- mMask = 0;
- client_handle = RPC_LOC_CLIENT_HANDLE_INVALID;
- ret_val = LOC_API_ADAPTER_ERR_INVALID_HANDLE;
- }
- }
-
- return ret_val;
-}
-
-enum loc_api_adapter_err
-LocApiRpc::close()
-{
- if (RPC_LOC_CLIENT_HANDLE_INVALID != client_handle) {
- loc_clear(client_handle);
- }
-
- loc_close(client_handle);
- mMask = 0;
- client_handle = RPC_LOC_CLIENT_HANDLE_INVALID;
-
- return LOC_API_ADAPTER_ERR_SUCCESS;
-}
-
-enum loc_api_adapter_err
-LocApiRpc::startFix(const LocPosMode& posMode) {
- LOC_LOGD("LocApiRpc::startFix() called");
- return convertErr(
- loc_start_fix(client_handle)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::stopFix() {
- LOC_LOGD("LocApiRpc::stopFix() called");
- return convertErr(
- loc_stop_fix(client_handle)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setPositionMode(const LocPosMode& posMode)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_fix_criteria_s_type *fix_criteria_ptr =
- &ioctl_data.rpc_loc_ioctl_data_u_type_u.fix_criteria;
- rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_SET_FIX_CRITERIA;
- rpc_loc_operation_mode_e_type op_mode;
- int ret_val;
- const LocPosMode* fixCriteria = &posMode;
-
- ALOGD ("loc_eng_set_position mode, client = %d, interval = %d, mode = %d\n",
- (int32) client_handle, fixCriteria->min_interval, fixCriteria->mode);
-
- switch (fixCriteria->mode)
- {
- case LOC_POSITION_MODE_MS_BASED:
- op_mode = RPC_LOC_OPER_MODE_MSB;
- break;
- case LOC_POSITION_MODE_MS_ASSISTED:
- op_mode = RPC_LOC_OPER_MODE_MSA;
- break;
- case LOC_POSITION_MODE_RESERVED_1:
- op_mode = RPC_LOC_OPER_MODE_SPEED_OPTIMAL;
- break;
- case LOC_POSITION_MODE_RESERVED_2:
- op_mode = RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL;
- break;
- case LOC_POSITION_MODE_RESERVED_3:
- op_mode = RPC_LOC_OPER_MODE_DATA_OPTIMAL;
- break;
- case LOC_POSITION_MODE_RESERVED_4:
- case LOC_POSITION_MODE_RESERVED_5:
- op_mode = RPC_LOC_OPER_MODE_MSA;
- fix_criteria_ptr->preferred_response_time = 0;
- break;
- default:
- op_mode = RPC_LOC_OPER_MODE_STANDALONE;
- }
-
- fix_criteria_ptr->valid_mask = RPC_LOC_FIX_CRIT_VALID_PREFERRED_OPERATION_MODE |
- RPC_LOC_FIX_CRIT_VALID_RECURRENCE_TYPE;
- fix_criteria_ptr->min_interval = fixCriteria->min_interval;
- fix_criteria_ptr->preferred_operation_mode = op_mode;
-
- fix_criteria_ptr->min_interval = fixCriteria->min_interval;
- fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_MIN_INTERVAL;
-
- if (fixCriteria->preferred_accuracy > 0) {
- fix_criteria_ptr->preferred_accuracy = fixCriteria->preferred_accuracy;
- fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_ACCURACY;
- }
- if (fixCriteria->preferred_time > 0) {
- fix_criteria_ptr->preferred_response_time = fixCriteria->preferred_time;
- fix_criteria_ptr->valid_mask |= RPC_LOC_FIX_CRIT_VALID_PREFERRED_RESPONSE_TIME;
- }
-
- switch (fixCriteria->recurrence) {
- case LOC_GPS_POSITION_RECURRENCE_SINGLE:
- fix_criteria_ptr->recurrence_type = RPC_LOC_SINGLE_FIX;
- break;
- case LOC_GPS_POSITION_RECURRENCE_PERIODIC:
- default:
- fix_criteria_ptr->recurrence_type = RPC_LOC_PERIODIC_FIX;
- break;
- }
- ioctl_data.disc = ioctl_type;
-
- ret_val = loc_eng_ioctl (client_handle,
- ioctl_type,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/);
-
- return convertErr(ret_val);
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_assist_data_time_s_type *time_info_ptr;
- rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_UTC_TIME;
- int ret_val;
-
- LOC_LOGD ("loc_eng_inject_time, uncertainty = %d\n", uncertainty);
-
- time_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_time;
- time_info_ptr->time_utc = time;
- time_info_ptr->time_utc += (int64_t)(ELAPSED_MILLIS_SINCE_BOOT_PLATFORM_LIB_ABSTRACTION - timeReference);
- time_info_ptr->uncertainty = uncertainty; // Uncertainty in ms
-
- ioctl_data.disc = ioctl_type;
-
- ret_val = loc_eng_ioctl (client_handle,
- ioctl_type,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/);
-
- return convertErr(ret_val);
-}
-
-enum loc_api_adapter_err
-LocApiRpc::injectPosition(double latitude, double longitude, float accuracy)
-{
- /* IOCTL data */
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_assist_data_pos_s_type *assistance_data_position =
- &ioctl_data.rpc_loc_ioctl_data_u_type_u.assistance_data_position;
- int ret_val;
-
- /************************************************
- * Fill in latitude, longitude & accuracy
- ************************************************/
-
- /* This combo is required */
- assistance_data_position->valid_mask =
- RPC_LOC_ASSIST_POS_VALID_LATITUDE |
- RPC_LOC_ASSIST_POS_VALID_LONGITUDE |
- RPC_LOC_ASSIST_POS_VALID_HOR_UNC_CIRCULAR |
- RPC_LOC_ASSIST_POS_VALID_CONFIDENCE_HORIZONTAL;
-
- assistance_data_position->latitude = latitude;
- assistance_data_position->longitude = longitude;
- assistance_data_position->hor_unc_circular = accuracy; /* Meters assumed */
- assistance_data_position->confidence_horizontal = 63; /* 63% (1 std dev) assumed */
-
- /* Log */
- LOC_LOGD("Inject coarse position Lat=%lf, Lon=%lf, Acc=%.2lf\n",
- (double) assistance_data_position->latitude,
- (double) assistance_data_position->longitude,
- (double) assistance_data_position->hor_unc_circular);
-
- ret_val = loc_eng_ioctl( client_handle,
- RPC_LOC_IOCTL_INJECT_POSITION,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/);
- return convertErr(ret_val);
-}
-
-enum loc_api_adapter_err
-LocApiRpc::informNiResponse(LocGpsUserResponseType userResponse,
- const void* passThroughData)
-{
- rpc_loc_ioctl_data_u_type data;
- rpc_loc_ioctl_callback_s_type callback_payload;
-
- memcpy(&data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.ni_event_pass_back,
- passThroughData, sizeof (rpc_loc_ni_event_s_type));
-
- rpc_loc_ni_user_resp_e_type resp;
- switch (userResponse)
- {
- case LOC_GPS_NI_RESPONSE_ACCEPT:
- data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT;
- break;
- case LOC_GPS_NI_RESPONSE_DENY:
- data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY;
- break;
- case LOC_GPS_NI_RESPONSE_NORESP:
- default:
- data.rpc_loc_ioctl_data_u_type_u.user_verify_resp.user_resp =
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP;
- break;
- }
-
- return convertErr(
- loc_eng_ioctl(client_handle,
- RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE,
- &data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- &callback_payload)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setAPN(char* apn, int len, boolean force)
-{
- enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS;
- int size = sizeof(apnLastSet);
- if (force || memcmp(apnLastSet, apn, size)) {
- if (len < size) {
- // size will be not larger than its original value
- size = len + 1;
- }
- memcpy(apnLastSet, apn, size);
-
- if (!isInSession()) {
- rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_LBS_APN_PROFILE, {0}};
- ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].srv_system_type = LOC_APN_PROFILE_SRV_SYS_MAX;
- ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].pdp_type = LOC_APN_PROFILE_PDN_TYPE_IPV4;
- memcpy(&(ioctl_data.rpc_loc_ioctl_data_u_type_u.apn_profiles[0].apn_name), apn, size);
-
- rtv = convertErr(
- loc_eng_ioctl (client_handle,
- RPC_LOC_IOCTL_SET_LBS_APN_PROFILE,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
- }
- }
- return rtv;
-}
-
-void LocApiRpc::setInSession(bool inSession)
-{
- if (!inSession) {
- enableData(dataEnableLastSet, true);
- setAPN(apnLastSet, sizeof(apnLastSet)-1, true);
- }
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setServer(const char* url, int len)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_server_info_s_type *server_info_ptr;
- rpc_loc_ioctl_e_type ioctl_cmd;
-
- ioctl_cmd = RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR;
- ioctl_data.disc = ioctl_cmd;
- server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr;
- server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_URL;
- server_info_ptr->addr_info.disc = server_info_ptr->addr_type;
- server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.length = len;
-#if (AMSS_VERSION==3200)
- server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_val = (char*) url;
- server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr.addr_len= len;
-#else
- strlcpy(server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr, url,
- sizeof server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.url.addr);
-#endif /* #if (AMSS_VERSION==3200) */
- LOC_LOGD ("loc_eng_set_server, addr = %s\n", url);
-
- return convertErr(
- loc_eng_ioctl (client_handle,
- ioctl_cmd,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setServer(unsigned int ip, int port, LocServerType type)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_server_info_s_type *server_info_ptr;
- rpc_loc_ioctl_e_type ioctl_cmd;
-
- switch (type) {
- case LOC_AGPS_MPC_SERVER:
- ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR;
- break;
- case LOC_AGPS_CUSTOM_PDE_SERVER:
- ioctl_cmd = RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR;
- break;
- default:
- ioctl_cmd = RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR;
- break;
- }
- ioctl_data.disc = ioctl_cmd;
- server_info_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.server_addr;
- server_info_ptr->addr_type = RPC_LOC_SERVER_ADDR_IPV4;
- server_info_ptr->addr_info.disc = server_info_ptr->addr_type;
- server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.addr = ip;
- server_info_ptr->addr_info.rpc_loc_server_addr_u_type_u.ipv4.port = port;
- LOC_LOGD ("setServer, addr = %X:%d\n", (unsigned int) ip, (unsigned int) port);
-
- return convertErr(
- loc_eng_ioctl (client_handle,
- ioctl_cmd,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::enableData(int enable, boolean force)
-{
- enum loc_api_adapter_err rtv = LOC_API_ADAPTER_ERR_SUCCESS;
- if (force || dataEnableLastSet != enable) {
- dataEnableLastSet = enable;
-
- if (!isInSession()) {
- rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_DATA_ENABLE, {0}};
-
- ioctl_data.rpc_loc_ioctl_data_u_type_u.data_enable = enable;
- rtv = convertErr(
- loc_eng_ioctl (client_handle,
- RPC_LOC_IOCTL_SET_DATA_ENABLE,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
- }
- }
- return rtv;
-}
-
-enum loc_api_adapter_err
-LocApiRpc::deleteAidingData(LocGpsAidingData bits)
-{
- rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_DELETE_ASSIST_DATA, {0}};
- ioctl_data.rpc_loc_ioctl_data_u_type_u.assist_data_delete.type = bits;
-
- return convertErr(
- loc_eng_ioctl (client_handle,
- RPC_LOC_IOCTL_DELETE_ASSIST_DATA,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
-}
-
-void LocApiRpc::reportPosition(const rpc_loc_parsed_position_s_type *location_report_ptr)
-{
- LocPosTechMask tech_Mask = LOC_POS_TECH_MASK_DEFAULT;
-
- UlpLocation location = {0};
- GpsLocationExtended locationExtended = {0};
-
- location.size = sizeof(location);
- locationExtended.size = sizeof(locationExtended);
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SESSION_STATUS)
- {
- // Process the position from final and intermediate reports
- if (location_report_ptr->session_status == RPC_LOC_SESS_STATUS_SUCCESS ||
- location_report_ptr->session_status == RPC_LOC_SESS_STATUS_IN_PROGESS)
- {
- // Latitude & Longitude
- if ((location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
- (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_LONGITUDE) &&
- (location_report_ptr->latitude != 0 ||
- location_report_ptr->longitude != 0))
- {
- location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_LAT_LONG;
- location.gpsLocation.latitude = location_report_ptr->latitude;
- location.gpsLocation.longitude = location_report_ptr->longitude;
-
- // Time stamp (UTC)
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_TIMESTAMP_UTC)
- {
- location.gpsLocation.timestamp = location_report_ptr->timestamp_utc;
- }
-
- // Altitude
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_ELLIPSOID )
- {
- location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_ALTITUDE;
- location.gpsLocation.altitude = location_report_ptr->altitude_wrt_ellipsoid;
- }
-
- // Speed
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_HORIZONTAL)
- {
- location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_SPEED;
- location.gpsLocation.speed = location_report_ptr->speed_horizontal;
- }
-
- // Heading
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HEADING)
- {
- location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_BEARING;
- location.gpsLocation.bearing = location_report_ptr->heading;
- }
-
- // Uncertainty (circular)
- if ( (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_HOR_UNC_CIRCULAR) )
- {
- location.gpsLocation.flags |= LOC_GPS_LOCATION_HAS_ACCURACY;
- location.gpsLocation.accuracy = location_report_ptr->hor_unc_circular;
- }
-
- // Technology Mask
-
- tech_Mask |= location_report_ptr->technology_mask;
- //Mark the location source as from GNSS
- location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
- location.position_source = ULP_LOCATION_IS_FROM_GNSS;
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_ALTITUDE_WRT_MEAN_SEA_LEVEL)
- {
- locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL;
- locationExtended.altitudeMeanSeaLevel = location_report_ptr->altitude_wrt_mean_sea_level;
- }
-
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_MAGNETIC_VARIATION )
- {
- locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_MAG_DEV;
- locationExtended.magneticDeviation = location_report_ptr->magnetic_deviation;
- }
-
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_VERTICAL_UNC)
- {
- locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_VERT_UNC;
- locationExtended.vert_unc = location_report_ptr->vert_unc;
- }
-
- if (location_report_ptr->valid_mask & RPC_LOC_POS_VALID_SPEED_UNC)
- {
- locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_SPEED_UNC;
- locationExtended.speed_unc = location_report_ptr->speed_unc;
- }
-
- LOC_LOGV("reportPosition: fire callback\n");
- enum loc_sess_status fixStatus =
- (location_report_ptr->session_status
- == RPC_LOC_SESS_STATUS_IN_PROGESS ?
- LOC_SESS_INTERMEDIATE : LOC_SESS_SUCCESS);
- LocApiBase::reportPosition(location,
- locationExtended,
- (void*)location_report_ptr,
- fixStatus,
- tech_Mask);
- }
- }
- else
- {
- LocApiBase::reportPosition(location,
- locationExtended,
- NULL,
- LOC_SESS_FAILURE);
- LOC_LOGV("loc_eng_report_position: ignore position report "
- "when session status = %d\n",
- location_report_ptr->session_status);
- }
- }
- else
- {
- LOC_LOGV("loc_eng_report_position: ignore position report "
- "when session status is not set\n");
- }
-}
-
-void LocApiRpc::reportSv(const rpc_loc_gnss_info_s_type *gnss_report_ptr)
-{
- QtiGnssSvStatus SvStatus = {0};
- GpsLocationExtended locationExtended = {0};
- locationExtended.size = sizeof(locationExtended);
- int num_svs_max = 0;
- const rpc_loc_sv_info_s_type *sv_info_ptr;
-
- if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
- {
- num_svs_max = gnss_report_ptr->sv_count;
- if (num_svs_max > LOC_GPS_MAX_SVS)
- {
- num_svs_max = LOC_GPS_MAX_SVS;
- }
- }
-
- if (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
- {
- SvStatus.num_svs = 0;
-
- for (int i = 0; i < num_svs_max; i++)
- {
- sv_info_ptr = &(gnss_report_ptr->sv_list.sv_list_val[i]);
- if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SYSTEM)
- {
- if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GPS)
- {
- SvStatus.sv_list[SvStatus.num_svs].size = sizeof(LocGpsSvInfo);
- SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn;
-
- // We only have the data field to report gps eph and alm mask
- if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_EPH) &&
- (sv_info_ptr->has_eph == 1))
- {
- SvStatus.ephemeris_mask |= (1 << (sv_info_ptr->prn-1));
- }
-
- if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_HAS_ALM) &&
- (sv_info_ptr->has_alm == 1))
- {
- SvStatus.almanac_mask |= (1 << (sv_info_ptr->prn-1));
- }
-
- if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) &&
- (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK))
- {
- SvStatus.gps_used_in_fix_mask |= (1 << (sv_info_ptr->prn-1));
- }
- }
- // SBAS: GPS RPN: 120-151,
- // In exteneded measurement report, we follow nmea standard, which is from 33-64.
- else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_SBAS)
- {
- SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + 33 - 120;
- }
- // Gloness: Slot id: 1-32
- // In extended measurement report, we follow nmea standard, which is 65-96
- else if (sv_info_ptr->system == RPC_LOC_SV_SYSTEM_GLONASS)
- {
- if ((sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_PROCESS_STATUS) &&
- (sv_info_ptr->process_status == RPC_LOC_SV_STATUS_TRACK))
- {
- SvStatus.glo_used_in_fix_mask |= (1 << (sv_info_ptr->prn-1));
- }
-
- SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->prn + (65-1);
- }
- // Unsupported SV system
- else
- {
- continue;
- }
- }
-
- if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_SNR)
- {
- SvStatus.sv_list[SvStatus.num_svs].snr = sv_info_ptr->snr;
- }
-
- if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_ELEVATION)
- {
- SvStatus.sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation;
- }
-
- if (sv_info_ptr->valid_mask & RPC_LOC_SV_INFO_VALID_AZIMUTH)
- {
- SvStatus.sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth;
- }
-
- SvStatus.num_svs++;
- }
- }
-
- if ((gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP) &&
- (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP) &&
- (gnss_report_ptr->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP))
- {
- locationExtended.flags |= GPS_LOCATION_EXTENDED_HAS_DOP;
- locationExtended.pdop = gnss_report_ptr->position_dop;
- locationExtended.hdop = gnss_report_ptr->horizontal_dop;
- locationExtended.vdop = gnss_report_ptr->vertical_dop;
- }
-
- if (SvStatus.num_svs >= 0)
- {
- LocApiBase::reportSv(SvStatus,
- locationExtended,
- (void*)gnss_report_ptr);
- }
-}
-
-void LocApiRpc::reportStatus(const rpc_loc_status_event_s_type *status_report_ptr)
-{
-
- if (status_report_ptr->event == RPC_LOC_STATUS_EVENT_ENGINE_STATE) {
- if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_ON)
- {
- LocApiBase::reportStatus(LOC_GPS_STATUS_ENGINE_ON);
- LocApiBase::reportStatus(LOC_GPS_STATUS_SESSION_BEGIN);
- }
- else if (status_report_ptr->payload.rpc_loc_status_event_payload_u_type_u.engine_state == RPC_LOC_ENGINE_STATE_OFF)
- {
- LocApiBase::reportStatus(LOC_GPS_STATUS_SESSION_END);
- LocApiBase::reportStatus(LOC_GPS_STATUS_ENGINE_OFF);
- }
- else
- {
- LocApiBase::reportStatus(LOC_GPS_STATUS_NONE);
- }
- }
-
-}
-
-void LocApiRpc::reportNmea(const rpc_loc_nmea_report_s_type *nmea_report_ptr)
-{
-
-#if (AMSS_VERSION==3200)
- LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences.nmea_sentences_val,
- nmea_report_ptr->nmea_sentences.nmea_sentences_len);
-#else
- LocApiBase::reportNmea(nmea_report_ptr->nmea_sentences,
- nmea_report_ptr->length);
- LOC_LOGD("loc_eng_report_nmea: $%c%c%c\n",
- nmea_report_ptr->nmea_sentences[3],
- nmea_report_ptr->nmea_sentences[4],
- nmea_report_ptr->nmea_sentences[5]);
-#endif /* #if (AMSS_VERSION==3200) */
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setXtraData(char* data, int length)
-{
- int rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
- int total_parts;
- uint8 part;
- uint16 part_len;
- uint16 len_injected;
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_ioctl_e_type ioctl_type = RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA;
- rpc_loc_predicted_orbits_data_s_type *predicted_orbits_data_ptr;
-
- LOC_LOGD("qct_loc_eng_inject_xtra_data, xtra size = %d, data ptr = 0x%lx\n", length, (long) data);
-
- predicted_orbits_data_ptr = &ioctl_data.rpc_loc_ioctl_data_u_type_u.predicted_orbits_data;
- predicted_orbits_data_ptr->format_type = RPC_LOC_PREDICTED_ORBITS_XTRA;
- predicted_orbits_data_ptr->total_size = length;
- total_parts = (length - 1) / XTRA_BLOCK_SIZE + 1;
- predicted_orbits_data_ptr->total_parts = total_parts;
-
- len_injected = 0; // O bytes injected
- ioctl_data.disc = ioctl_type;
-
- // XTRA injection starts with part 1
- for (part = 1; part <= total_parts; part++)
- {
- predicted_orbits_data_ptr->part = part;
- predicted_orbits_data_ptr->part_len = XTRA_BLOCK_SIZE;
- if (XTRA_BLOCK_SIZE > (length - len_injected))
- {
- predicted_orbits_data_ptr->part_len = length - len_injected;
- }
- predicted_orbits_data_ptr->data_ptr.data_ptr_len = predicted_orbits_data_ptr->part_len;
- predicted_orbits_data_ptr->data_ptr.data_ptr_val = data + len_injected;
-
- LOC_LOGD("qct_loc_eng_inject_xtra_data, part %d/%d, len = %d, total = %d\n",
- predicted_orbits_data_ptr->part,
- total_parts,
- predicted_orbits_data_ptr->part_len,
- len_injected);
-
- if (part < total_parts)
- {
- // No callback in this case
- rpc_ret_val = loc_ioctl (client_handle,
- ioctl_type,
- &ioctl_data);
-
- if (rpc_ret_val != RPC_LOC_API_SUCCESS)
- {
- LOC_LOGE("loc_ioctl for xtra error: %s\n", loc_get_ioctl_status_name(rpc_ret_val));
- break;
- }
- //Add a delay of 10 ms so that repeated RPC calls dont starve the modem processor
- usleep(10 * 1000);
- }
- else // part == total_parts
- {
- // Last part injection, will need to wait for callback
- if (!loc_eng_ioctl(client_handle,
- ioctl_type,
- &ioctl_data,
- LOC_XTRA_INJECT_DEFAULT_TIMEOUT,
- NULL))
- {
- rpc_ret_val = RPC_LOC_API_GENERAL_FAILURE;
- }
- break; // done with injection
- }
-
- len_injected += predicted_orbits_data_ptr->part_len;
- LOC_LOGD("loc_ioctl XTRA injected length: %d\n", len_injected);
- }
-
- return convertErr(rpc_ret_val);
-}
-
-/* Request the Xtra Server Url from the modem */
-enum loc_api_adapter_err
-LocApiRpc::requestXtraServer()
-{
- loc_api_adapter_err err;
- rpc_loc_ioctl_data_u_type data;
- rpc_loc_ioctl_callback_s_type callback_data;
-
- err = convertErr(loc_eng_ioctl(client_handle,
- RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE,
- &data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- &callback_data));
-
- if (LOC_API_ADAPTER_ERR_SUCCESS != err)
- {
- LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: err=%d\n", err);
- return err;
- }
- else if (RPC_LOC_SESS_STATUS_SUCCESS != callback_data.status)
- {
- LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE failed!: status=%ld\n", callback_data.status);
- return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
- }
- else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.type)
- {
- LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the type expected! type=%d\n", callback_data.type);
- return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
- }
- else if (RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE != callback_data.data.disc)
- {
- LOC_LOGE("RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE is not the disc expected! disc=%d\n", callback_data.data.disc);
- return LOC_API_ADAPTER_ERR_GENERAL_FAILURE;
- }
-
- reportXtraServer(callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
- predicted_orbits_data_source.servers[0],
- callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
- predicted_orbits_data_source.servers[1],
- callback_data.data.rpc_loc_ioctl_callback_data_u_type_u.
- predicted_orbits_data_source.servers[2],
- 255);
-
- return LOC_API_ADAPTER_ERR_SUCCESS;
-}
-
-enum loc_api_adapter_err
-LocApiRpc::atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, LocAGpsType agpsType)
-{
- rpc_loc_server_open_status_e_type open_status = is_succ ? RPC_LOC_SERVER_OPEN_SUCCESS : RPC_LOC_SERVER_OPEN_FAIL;
- rpc_loc_ioctl_data_u_type ioctl_data;
-
- if (LOC_AGPS_TYPE_INVALID == agpsType) {
- rpc_loc_server_open_status_s_type *conn_open_status_ptr =
- &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_open_status;
-
- // Fill in data
- ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS;
- conn_open_status_ptr->conn_handle = handle;
- conn_open_status_ptr->open_status = open_status;
-#if (AMSS_VERSION==3200)
- conn_open_status_ptr->apn_name = apn; /* requires APN */
-#else
- if (is_succ) {
- strlcpy(conn_open_status_ptr->apn_name, apn,
- sizeof conn_open_status_ptr->apn_name);
- } else {
- conn_open_status_ptr->apn_name[0] = 0;
- }
-#endif /* #if (AMSS_VERSION==3200) */
-
- LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS open %s, APN name = [%s]\n",
- log_succ_fail_string(is_succ),
- apn);
- } else {
- rpc_loc_server_multi_open_status_s_type *conn_multi_open_status_ptr =
- &ioctl_data.rpc_loc_ioctl_data_u_type_u.multi_conn_open_status;
-
- // Fill in data
- ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS;
- conn_multi_open_status_ptr->conn_handle = handle;
- conn_multi_open_status_ptr->open_status = open_status;
- if (is_succ) {
- strlcpy(conn_multi_open_status_ptr->apn_name, apn,
- sizeof conn_multi_open_status_ptr->apn_name);
- } else {
- conn_multi_open_status_ptr->apn_name[0] = 0;
- }
-
- switch(bearer)
- {
- case AGPS_APN_BEARER_IPV4:
- conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IP;
- break;
- case AGPS_APN_BEARER_IPV6:
- conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV6;
- break;
- case AGPS_APN_BEARER_IPV4V6:
- conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_IPV4V6;
- break;
- default:
- conn_multi_open_status_ptr->pdp_type = RPC_LOC_SERVER_PDP_PPP;
- }
-
- LOC_LOGD("ATL RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS open %s, APN name = [%s], pdp_type = %d\n",
- log_succ_fail_string(is_succ),
- apn,
- conn_multi_open_status_ptr->pdp_type);
- }
-
- // Make the IOCTL call
- return convertErr(
- loc_eng_ioctl(client_handle,
- ioctl_data.disc,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
-}
-
-enum loc_api_adapter_err
-LocApiRpc::atlCloseStatus(int handle, int is_succ)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- ioctl_data.disc = RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS;
-
- rpc_loc_server_close_status_s_type *conn_close_status_ptr =
- &ioctl_data.rpc_loc_ioctl_data_u_type_u.conn_close_status;
- conn_close_status_ptr->conn_handle = handle;
- conn_close_status_ptr->close_status = is_succ ? RPC_LOC_SERVER_CLOSE_SUCCESS : RPC_LOC_SERVER_CLOSE_FAIL;
-
- // Make the IOCTL call
- return convertErr(
- loc_eng_ioctl(client_handle,
- ioctl_data.disc,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
-}
-
-void LocApiRpc::ATLEvent(const rpc_loc_server_request_s_type *server_request_ptr)
-{
- int connHandle;
- LocAGpsType agps_type;
-
- LOC_LOGV("RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST event %s)",
- loc_get_event_atl_open_name(server_request_ptr->event));
- switch (server_request_ptr->event)
- {
- case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
- connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.conn_handle;
- if (server_request_ptr->payload.rpc_loc_server_request_u_type_u.multi_open_req.connection_type
- == RPC_LOC_SERVER_CONNECTION_LBS) {
- agps_type = LOC_AGPS_TYPE_SUPL;
- LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - LOC_AGPS_TYPE_SUPL\n handle - %d", connHandle);
- } else {
- agps_type = LOC_AGPS_TYPE_WWAN_ANY;
- LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_MULTI_OPEN\n type - LOC_AGPS_TYPE_WWAN_ANY\n handle - %d", connHandle);
- }
- requestATL(connHandle, agps_type);
- break;
- case RPC_LOC_SERVER_REQUEST_OPEN:
- connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.open_req.conn_handle;
- LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_OPEN\n handle - %d", connHandle);
- requestATL(connHandle, LOC_AGPS_TYPE_INVALID);
- break;
- case RPC_LOC_SERVER_REQUEST_CLOSE:
- connHandle = server_request_ptr->payload.rpc_loc_server_request_u_type_u.close_req.conn_handle;
- LOC_LOGV("ATLEvent: event - RPC_LOC_SERVER_REQUEST_CLOSE\n handle - %d", connHandle);
- releaseATL(connHandle);
- break;
- default:
- LOC_LOGE("ATLEvent: event type %d invalid", server_request_ptr->event);
- }
-}
-
-void LocApiRpc::NIEvent(const rpc_loc_ni_event_s_type *ni_req)
-{
- LocGpsNiNotification notif = {0};
-
- switch (ni_req->event)
- {
- case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
- {
- const rpc_loc_ni_vx_notify_verify_req_s_type *vx_req =
- &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.vx_req;
- LOC_LOGI("VX Notification");
- notif.ni_type = LOC_GPS_NI_TYPE_VOICE;
- // Requestor ID
- hexcode(notif.requestor_id, sizeof notif.requestor_id,
- vx_req->requester_id.requester_id,
- vx_req->requester_id.requester_id_length);
- notif.text_encoding = 0; // No text and no encoding
- notif.requestor_id_encoding = convertNiEncodingType(vx_req->encoding_scheme);
- NIEventFillVerfiyType(notif, vx_req->notification_priv_type);
- }
- break;
-
- case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
- {
- const rpc_loc_ni_umts_cp_notify_verify_req_s_type *umts_cp_req =
- &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.umts_cp_req;
- LOC_LOGI("UMTS CP Notification\n");
- notif.ni_type= LOC_GPS_NI_TYPE_UMTS_CTRL_PLANE; // Stores notification text
-#if (AMSS_VERSION==3200)
- hexcode(notif.text, sizeof notif.text,
- umts_cp_req->notification_text.notification_text_val,
- umts_cp_req->notification_length);
- hexcode(notif.requestor_id, sizeof notif.requestor_id,
- umts_cp_req->requestor_id.requestor_id_string.requestor_id_string_val,
- umts_cp_req->requestor_id.string_len);
-#else
- hexcode(notif.text, sizeof notif.text,
- umts_cp_req->notification_text,
- umts_cp_req->notification_length);
- hexcode(notif.requestor_id, sizeof notif.requestor_id,
- umts_cp_req->requestor_id.requestor_id_string,
- umts_cp_req->requestor_id.string_len);
-#endif
- notif.text_encoding = convertNiEncodingType(umts_cp_req->datacoding_scheme);
- notif.requestor_id_encoding = notif.text_encoding;
- NIEventFillVerfiyType(notif, umts_cp_req->notification_priv_type);
-
- // LCS address (using extras field)
- if (umts_cp_req->ext_client_address_data.ext_client_address_len != 0)
- {
- // Copy LCS Address into notif.extras in the format: Address = 012345
- strlcat(notif.extras, LOC_NI_NOTIF_KEY_ADDRESS, sizeof notif.extras);
- strlcat(notif.extras, " = ", sizeof notif.extras);
- int addr_len = 0;
- const char *address_source = NULL;
-
-#if (AMSS_VERSION==3200)
- address_source = umts_cp_req->ext_client_address_data.ext_client_address.ext_client_address_val;
-#else
- address_source = umts_cp_req->ext_client_address_data.ext_client_address;
-#endif /* #if (AMSS_VERSION==3200) */
-
- char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
- addr_len = decodeAddress(lcs_addr, sizeof lcs_addr, address_source,
- umts_cp_req->ext_client_address_data.ext_client_address_len);
-
- // The address is ASCII string
- if (addr_len)
- {
- strlcat(notif.extras, lcs_addr, sizeof notif.extras);
- }
- }
- }
- break;
-
- case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
- {
- const rpc_loc_ni_supl_notify_verify_req_s_type *supl_req =
- &ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req;
- LOC_LOGI("SUPL Notification\n");
- notif.ni_type = LOC_GPS_NI_TYPE_UMTS_SUPL;
-
- if (supl_req->flags & RPC_LOC_NI_CLIENT_NAME_PRESENT)
- {
-#if (AMSS_VERSION==3200)
- hexcode(notif.text, sizeof notif.text,
- supl_req->client_name.client_name_string.client_name_string_val, /* buffer */
- supl_req->client_name.string_len /* length */
- );
-#else
- hexcode(notif.text, sizeof notif.text,
- supl_req->client_name.client_name_string, /* buffer */
- supl_req->client_name.string_len /* length */
- );
-#endif /* #if (AMSS_VERSION==3200) */
- LOC_LOGV("SUPL NI: client_name: %s len=%d", notif.text, supl_req->client_name.string_len);
- }
- else {
- LOC_LOGV("SUPL NI: client_name not present.");
- }
-
- // Requestor ID
- if (supl_req->flags & RPC_LOC_NI_REQUESTOR_ID_PRESENT)
- {
-#if (AMSS_VERSION==3200)
- hexcode(notif.requestor_id, sizeof notif.requestor_id,
- supl_req->requestor_id.requestor_id_string.requestor_id_string_val, /* buffer */
- supl_req->requestor_id.string_len /* length */
- );
-#else
- hexcode(notif.requestor_id, sizeof notif.requestor_id,
- supl_req->requestor_id.requestor_id_string, /* buffer */
- supl_req->requestor_id.string_len /* length */
- );
-#endif /* #if (AMSS_VERSION==3200) */
- LOC_LOGV("SUPL NI: requestor_id: %s len=%d", notif.requestor_id, supl_req->requestor_id.string_len);
- }
- else {
- LOC_LOGV("SUPL NI: requestor_id not present.");
- }
-
- // Encoding type
- if (supl_req->flags & RPC_LOC_NI_ENCODING_TYPE_PRESENT)
- {
- notif.text_encoding = convertNiEncodingType(supl_req->datacoding_scheme);
- notif.requestor_id_encoding = notif.text_encoding;
- }
- else {
- notif.text_encoding = notif.requestor_id_encoding = LOC_GPS_ENC_UNKNOWN;
- }
-
- NIEventFillVerfiyType(notif, ni_req->payload.rpc_loc_ni_event_payload_u_type_u.supl_req.notification_priv_type);
- }
- break;
-
- default:
- LOC_LOGE("Unknown NI event: %x\n", (int) ni_req->event);
- return;
- }
-
- // this copy will get freed in loc_eng_ni when loc_ni_respond() is called
- rpc_loc_ni_event_s_type *copy = (rpc_loc_ni_event_s_type *)malloc(sizeof(*copy));
- memcpy(copy, ni_req, sizeof(*copy));
- requestNiNotify(notif, (const void*)copy);
-}
-
-int LocApiRpc::NIEventFillVerfiyType(LocGpsNiNotification ¬if,
- rpc_loc_ni_notify_verify_e_type notif_priv)
-{
- switch (notif_priv)
- {
- case RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY:
- notif.notify_flags = 0;
- notif.default_response = LOC_GPS_NI_RESPONSE_NORESP;
- return 1;
- case RPC_LOC_NI_USER_NOTIFY_ONLY:
- notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY;
- notif.default_response = LOC_GPS_NI_RESPONSE_NORESP;
- return 1;
- case RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP:
- notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY | LOC_GPS_NI_NEED_VERIFY;
- notif.default_response = LOC_GPS_NI_RESPONSE_ACCEPT;
- return 1;
- case RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP:
- notif.notify_flags = LOC_GPS_NI_NEED_NOTIFY | LOC_GPS_NI_NEED_VERIFY;
- notif.default_response = LOC_GPS_NI_RESPONSE_DENY;
- return 1;
- case RPC_LOC_NI_USER_PRIVACY_OVERRIDE:
- notif.notify_flags = LOC_GPS_NI_PRIVACY_OVERRIDE;
- notif.default_response = LOC_GPS_NI_RESPONSE_NORESP;
- return 1;
- default:
- return 0;
- }
-}
-
-enum loc_api_adapter_err
-LocApiRpc::setSUPLVersion(uint32_t version)
-{
- rpc_loc_ioctl_data_u_type ioctl_data = {RPC_LOC_IOCTL_SET_SUPL_VERSION, {0}};
- ioctl_data.rpc_loc_ioctl_data_u_type_u.supl_version = (int)version;
- return convertErr(
- loc_eng_ioctl (client_handle,
- RPC_LOC_IOCTL_SET_SUPL_VERSION,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL)
- );
-}
-
-LocGpsNiEncodingType LocApiRpc::convertNiEncodingType(int loc_encoding)
-{
- switch (loc_encoding)
- {
- case RPC_LOC_NI_SUPL_UTF8:
- return LOC_GPS_ENC_SUPL_UTF8;
- case RPC_LOC_NI_SUPL_UCS2:
- return LOC_GPS_ENC_SUPL_UCS2;
- case RPC_LOC_NI_SUPL_GSM_DEFAULT:
- return LOC_GPS_ENC_SUPL_GSM_DEFAULT;
- case RPC_LOC_NI_SS_LANGUAGE_UNSPEC:
- return LOC_GPS_ENC_SUPL_GSM_DEFAULT; // SS_LANGUAGE_UNSPEC = GSM
- default:
- return LOC_GPS_ENC_UNKNOWN;
- }
-}
-
-LocApiBase* getLocApi(const MsgTask* msgTask,
- LOC_API_ADAPTER_EVENT_MASK_T exMask,
- ContextBase *context) {
- return new LocApiRpc(msgTask, exMask, context);
-}
-
-/*Values for lock
- 1 = Do not lock any position sessions
- 2 = Lock MI position sessions
- 3 = Lock MT position sessions
- 4 = Lock all position sessions
-*/
-int LocApiRpc::setGpsLock(LOC_GPS_LOCK_MASK lockMask)
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- boolean ret_val;
- LOC_LOGD("%s:%d]: lock: %x\n", __func__, __LINE__, lockMask);
- ioctl_data.rpc_loc_ioctl_data_u_type_u.engine_lock = convertGpsLockMask(lockMask);
- ioctl_data.disc = RPC_LOC_IOCTL_SET_ENGINE_LOCK;
- ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
- RPC_LOC_IOCTL_SET_ENGINE_LOCK,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- NULL /* No output information is expected*/);
-
- LOC_LOGD("%s:%d]: ret_val: %d\n", __func__, __LINE__, (int)ret_val);
- return (ret_val == TRUE ? 0 : -1);
-}
-
-/*
- Returns
- Current value of GPS lock on success
- -1 on failure
-*/
-int LocApiRpc :: getGpsLock()
-{
- rpc_loc_ioctl_data_u_type ioctl_data;
- rpc_loc_ioctl_callback_s_type callback_payload;
- boolean ret_val;
- int ret=0;
- LOC_LOGD("%s:%d]: Enter\n", __func__, __LINE__);
- ret_val = loc_eng_ioctl (loc_eng_data.client_handle,
- RPC_LOC_IOCTL_GET_ENGINE_LOCK,
- &ioctl_data,
- LOC_IOCTL_DEFAULT_TIMEOUT,
- &callback_payload);
- if(ret_val == TRUE) {
- ret = (int)callback_payload.data.engine_lock;
- LOC_LOGD("%s:%d]: Lock type: %d\n", __func__, __LINE__, ret);
- }
- else {
- LOC_LOGE("%s:%d]: Ioctl failed", __func__, __LINE__);
- ret = -1;
- }
- LOC_LOGD("%s:%d]: Exit\n", __func__, __LINE__);
- return ret;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c
deleted file mode 100644
index 837ef11..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_fixup.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <rpc/rpc.h>
-
-#include "loc_api_fixup.h"
-
-#ifdef ADD_XDR_FLOAT
-
-int
-xdr_float(xdrp, fp)
- XDR *xdrp;
- float *fp;
-{
- return xdr_long(xdrp, (long*)fp);
-}
-
-int
-xdr_double(xdrp, dp)
- XDR *xdrp;
- double *dp;
-{
- return xdr_long(xdrp, (long*)dp + 1)
- && xdr_long(xdrp, (long*)dp);
-}
-
-#endif /* ADD_XDR_FLOAT */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c
deleted file mode 100644
index eb685fd..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_log.c
+++ /dev/null
@@ -1,344 +0,0 @@
-/* Copyright (c) 2011, 2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_api_rpc_glue"
-
-#include "loc_api_log.h"
-#include "loc_log.h"
-#include "platform_lib_includes.h"
-#include "rpc/rpc.h"
-#include "loc_api_fixup.h"
-
-/* Event names */
-loc_name_val_s_type loc_event_name[] =
- {
- NAME_VAL( RPC_LOC_EVENT_PARSED_POSITION_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_SATELLITE_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_NMEA_1HZ_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_NMEA_POSITION_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST ),
- NAME_VAL( RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST ),
- NAME_VAL( RPC_LOC_EVENT_LOCATION_SERVER_REQUEST ),
- NAME_VAL( RPC_LOC_EVENT_IOCTL_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_STATUS_REPORT ),
- NAME_VAL( RPC_LOC_EVENT_WPS_NEEDED_REQUEST ),
- };
-int loc_event_num = sizeof loc_event_name / sizeof(loc_name_val_s_type);
-
-/* Event names */
-loc_name_val_s_type loc_event_atl_open_name[] =
- {
- NAME_VAL( RPC_LOC_SERVER_REQUEST_OPEN ),
- NAME_VAL( RPC_LOC_SERVER_REQUEST_CLOSE ),
- NAME_VAL( RPC_LOC_SERVER_REQUEST_MULTI_OPEN )
- };
-int loc_event_atl_open_num = sizeof loc_event_atl_open_name / sizeof(loc_name_val_s_type);
-
-/* Finds the first event found in the mask */
-const char* loc_get_event_atl_open_name(rpc_loc_server_request_e_type loc_event_atl_open)
-{
- return loc_get_name_from_val(loc_event_atl_open_name, loc_event_atl_open_num,
- (long) loc_event_atl_open);
-}
-
-/* IOCTL Type names */
-loc_name_val_s_type loc_ioctl_type_name[] =
- {
- NAME_VAL( RPC_LOC_IOCTL_GET_API_VERSION ),
- NAME_VAL( RPC_LOC_IOCTL_SET_FIX_CRITERIA ),
- NAME_VAL( RPC_LOC_IOCTL_GET_FIX_CRITERIA ),
- NAME_VAL( RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE ),
- NAME_VAL( RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA ),
- NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY ),
- NAME_VAL( RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE ),
- NAME_VAL( RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD ),
- NAME_VAL( RPC_LOC_IOCTL_INJECT_UTC_TIME ),
- NAME_VAL( RPC_LOC_IOCTL_INJECT_RTC_VALUE ),
- NAME_VAL( RPC_LOC_IOCTL_INJECT_POSITION ),
- NAME_VAL( RPC_LOC_IOCTL_QUERY_ENGINE_STATE ),
- NAME_VAL( RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG),
- NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS ),
- NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS ),
- NAME_VAL( RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS ),
- NAME_VAL( RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT ),
- NAME_VAL( RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS ),
- NAME_VAL( RPC_LOC_IOCTL_SET_ENGINE_LOCK ),
- NAME_VAL( RPC_LOC_IOCTL_GET_ENGINE_LOCK ),
- NAME_VAL( RPC_LOC_IOCTL_SET_SBAS_CONFIG ),
- NAME_VAL( RPC_LOC_IOCTL_GET_SBAS_CONFIG ),
- NAME_VAL( RPC_LOC_IOCTL_SET_NMEA_TYPES ),
- NAME_VAL( RPC_LOC_IOCTL_GET_NMEA_TYPES ),
- NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_SET_ON_DEMAND_LPM ),
- NAME_VAL( RPC_LOC_IOCTL_GET_ON_DEMAND_LPM ),
- NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL ),
- NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL ),
- NAME_VAL( RPC_LOC_IOCTL_SET_LBS_APN_PROFILE ),
- NAME_VAL( RPC_LOC_IOCTL_GET_LBS_APN_PROFILE ),
- NAME_VAL( RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE ),
- NAME_VAL( RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE ),
- NAME_VAL( RPC_LOC_IOCTL_SET_DATA_ENABLE ),
- NAME_VAL( RPC_LOC_IOCTL_SET_SUPL_VERSION ),
- NAME_VAL( RPC_LOC_IOCTL_GET_SUPL_VERSION ),
- NAME_VAL( RPC_LOC_IOCTL_DELETE_ASSIST_DATA ),
- NAME_VAL( RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR ),
- NAME_VAL( RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR ),
- };
-int loc_ioctl_type_num = sizeof loc_ioctl_type_name / sizeof(loc_name_val_s_type);
-
-/* IOCTL Status names */
-loc_name_val_s_type loc_ioctl_status_name[] =
- {
- NAME_VAL( RPC_LOC_API_SUCCESS ),
- NAME_VAL( RPC_LOC_API_GENERAL_FAILURE ),
- NAME_VAL( RPC_LOC_API_UNSUPPORTED ),
- NAME_VAL( RPC_LOC_API_INVALID_HANDLE ),
- NAME_VAL( RPC_LOC_API_INVALID_PARAMETER ),
- NAME_VAL( RPC_LOC_API_ENGINE_BUSY ),
- NAME_VAL( RPC_LOC_API_PHONE_OFFLINE ),
- NAME_VAL( RPC_LOC_API_TIMEOUT ),
- NAME_VAL( RPC_LOC_API_RPC_FAILURE ),
- NAME_VAL( RPC_LOC_API_RPC_MODEM_RESTART )
- };
-int loc_ioctl_status_num = sizeof loc_ioctl_status_name / sizeof(loc_name_val_s_type);
-
-/* Fix session status names */
-loc_name_val_s_type loc_sess_status_name[] =
- {
- NAME_VAL( RPC_LOC_SESS_STATUS_SUCCESS ),
- NAME_VAL( RPC_LOC_SESS_STATUS_IN_PROGESS ),
- NAME_VAL( RPC_LOC_SESS_STATUS_GENERAL_FAILURE ),
- NAME_VAL( RPC_LOC_SESS_STATUS_TIMEOUT ),
- NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
- NAME_VAL( RPC_LOC_SESS_STATUS_BAD_PARAMETER ),
- NAME_VAL( RPC_LOC_SESS_STATUS_PHONE_OFFLINE ),
- NAME_VAL( RPC_LOC_SESS_STATUS_USER_END ),
- NAME_VAL( RPC_LOC_SESS_STATUS_ENGINE_LOCKED )
- };
-int loc_sess_status_num = sizeof loc_sess_status_name / sizeof(loc_name_val_s_type);
-
-/* Engine state names */
-loc_name_val_s_type loc_engine_state_name[] =
- {
- NAME_VAL( RPC_LOC_ENGINE_STATE_ON ),
- NAME_VAL( RPC_LOC_ENGINE_STATE_OFF )
- };
-int loc_engine_state_num = sizeof loc_engine_state_name / sizeof(loc_name_val_s_type);
-
-/* Fix session state names */
-loc_name_val_s_type loc_fix_session_state_name[] =
- {
- NAME_VAL( RPC_LOC_FIX_SESSION_STATE_BEGIN ),
- NAME_VAL( RPC_LOC_FIX_SESSION_STATE_END )
- };
-int loc_fix_session_state_num = sizeof loc_fix_session_state_name / sizeof(loc_name_val_s_type);
-
-
-static const char* log_final_interm_string(int is_final)
-{
- return is_final ? "final" : "intermediate";
-}
-
-/* Logs parsed report */
-static void log_parsed_report(const rpc_loc_parsed_position_s_type *parsed_report)
-{
- rpc_loc_session_status_e_type status = parsed_report->session_status;
- LOC_LOGD("Session status: %s Valid mask: 0x%X\n",
- loc_get_sess_status_name(status),
- (uint) parsed_report->valid_mask);
- LOC_LOGD("Latitude: %.7f (%s)\n", parsed_report->latitude,
- log_final_interm_string(
- (parsed_report->valid_mask & RPC_LOC_POS_VALID_LATITUDE) &&
- parsed_report->session_status == RPC_LOC_SESS_STATUS_SUCCESS));
- LOC_LOGD("Longitude: %.7f\n", parsed_report->longitude);
- LOC_LOGD("Accuracy: %.7f\n", parsed_report->hor_unc_circular);
-}
-
-/* Logs status report */
-static void log_status_report(const rpc_loc_status_event_s_type *status_event)
-{
- rpc_loc_status_event_e_type event = status_event->event;
- switch (event) {
- case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
- LOC_LOGD("Engine state: %s\n",
- loc_get_engine_state_name(
- status_event->payload.rpc_loc_status_event_payload_u_type_u.engine_state));
- break;
- case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
- LOC_LOGD("Fix session state: %s\n",
- loc_get_fix_session_state_name(
- status_event->payload.rpc_loc_status_event_payload_u_type_u.fix_session_state));
- break;
- default:
- break;
- }
-}
-
-/* Logs valid fields in the GNSS SV constellation report */
-static void log_satellite_report(const rpc_loc_gnss_info_s_type *gnss)
-{
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_POS_DOP)
- {
- LOC_LOGV("position dop: %.3f\n", (float) gnss->position_dop);
- }
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_HOR_DOP)
- {
- LOC_LOGV("horizontal dop: %.3f\n", (float) gnss->horizontal_dop);
- }
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_VERT_DOP)
- {
- LOC_LOGV("vertical dop: %.3f\n", (float) gnss->vertical_dop);
- }
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_ALTITUDE_ASSUMED)
- {
- LOC_LOGV("altitude assumed: %d\n", (int) gnss->altitude_assumed);
- }
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_COUNT)
- {
- LOC_LOGD("sv count: %d\n", (int) gnss->sv_count);
- }
- if (gnss->valid_mask & RPC_LOC_GNSS_INFO_VALID_SV_LIST)
- {
- LOC_LOGV("sv list: ");
-
- if (gnss->sv_count)
- {
- LOC_LOGV("\n\tsys\tprn\thlth\tproc\teph\talm\telev\tazi\tsnr\n");
- }
- else {
- LOC_LOGV("empty\n");
- }
-
- int i;
- for (i = 0; i < gnss->sv_count; i++)
- {
- const rpc_loc_sv_info_s_type *sv = &gnss->sv_list.sv_list_val[i];
- rpc_loc_sv_info_valid_mask_type mask = sv->valid_mask;
- LOC_LOGV(" %d: \t%d\t%d\t%d\t%d\t%d\t%d\t%.3f\t%.3f\t%.3f\n", i,
- CHECK_MASK(int, sv->system, mask, RPC_LOC_SV_INFO_VALID_SYSTEM),
- CHECK_MASK(int, sv->prn, mask, RPC_LOC_SV_INFO_VALID_PRN),
- CHECK_MASK(int, sv->health_status, mask, RPC_LOC_SV_INFO_VALID_HEALTH_STATUS),
- CHECK_MASK(int, sv->process_status, mask, RPC_LOC_SV_INFO_VALID_PROCESS_STATUS),
- CHECK_MASK(int, sv->has_eph, mask, RPC_LOC_SV_INFO_VALID_HAS_EPH),
- CHECK_MASK(int, sv->has_alm, mask, RPC_LOC_SV_INFO_VALID_HAS_ALM),
- CHECK_MASK(float, sv->elevation, mask, RPC_LOC_SV_INFO_VALID_ELEVATION),
- CHECK_MASK(float, sv->azimuth, mask, RPC_LOC_SV_INFO_VALID_AZIMUTH),
- CHECK_MASK(float, sv->snr, mask, RPC_LOC_SV_INFO_VALID_SNR)
- );
- }
- }
-}
-
-/* Logs a callback event */
-int loc_callback_log(
- rpc_loc_event_mask_type loc_event, /* event mask */
- const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
-)
-{
- switch (loc_event)
- {
- case RPC_LOC_EVENT_SATELLITE_REPORT:
- log_satellite_report(&loc_event_payload->
- rpc_loc_event_payload_u_type_u.gnss_report);
- break;
- case RPC_LOC_EVENT_STATUS_REPORT:
- log_status_report(&loc_event_payload->
- rpc_loc_event_payload_u_type_u.status_report);
- break;
- case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
- log_parsed_report(&loc_event_payload->
- rpc_loc_event_payload_u_type_u.parsed_location_report);
- break;
- default:
- break;
- }
-
- return 0;
-}
-
-/* Finds the first event found in the mask */
-const char* loc_get_event_name(rpc_loc_event_mask_type loc_event_mask)
-{
- return loc_get_name_from_mask(loc_event_name, loc_event_num,
- (long) loc_event_mask);
-}
-
-/* Finds IOCTL type name */
-const char* loc_get_ioctl_type_name(rpc_loc_ioctl_e_type ioctl_type)
-{
- return loc_get_name_from_val(loc_ioctl_type_name, loc_ioctl_type_num,
- (long) ioctl_type);
-}
-
-/* Finds IOCTL status name */
-const char* loc_get_ioctl_status_name(uint32 status)
-{
- return loc_get_name_from_val(loc_ioctl_status_name, loc_ioctl_status_num,
- (long) status);
-}
-
-/* Finds session status name */
-const char* loc_get_sess_status_name(rpc_loc_session_status_e_type status)
-{
- return loc_get_name_from_val(loc_sess_status_name, loc_sess_status_num,
- (long) status);
-}
-
-/* Find engine state name */
-const char* loc_get_engine_state_name(rpc_loc_engine_state_e_type state)
-{
- return loc_get_name_from_val(loc_engine_state_name, loc_engine_state_num,
- (long) state);
-}
-
-/* Find engine state name */
-const char* loc_get_fix_session_state_name(rpc_loc_fix_session_state_e_type state)
-{
- return loc_get_name_from_val(loc_fix_session_state_name, loc_fix_session_state_num,
- (long) state);
-}
-
-/* Event names */
-loc_name_val_s_type rpc_reset_event_name[] =
-{
- NAME_VAL( RPC_SUBSYSTEM_RESTART_BEGIN ),
- NAME_VAL( RPC_SUBSYSTEM_RESTART_END )
-};
-int rpc_reset_event_num = sizeof rpc_reset_event_name / sizeof(loc_name_val_s_type);
-
-const char* loc_get_rpc_reset_event_name(enum rpc_reset_event event)
-{
- return loc_get_name_from_val(rpc_reset_event_name, rpc_reset_event_num, event);
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c
deleted file mode 100644
index 8c12426..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_rpc_glue.c
+++ /dev/null
@@ -1,635 +0,0 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*=====================================================================
-
- INCLUDE FILES FOR MODULE
-
-======================================================================*/
-#include <stdio.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/select.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <loc_api_log.h>
-
-#include <rpc/rpc.h>
-
-/* Include RPC headers */
-#include "rpc_inc/loc_api_rpc_glue.h"
-
-/* Callback init */
-#include "rpc_inc/loc_apicb_appinit.h"
-
-/* Logging */
-#define LOG_TAG "LocSvc_api_rpc_glue"
-#define LOG_NDDEBUG 0
-#ifndef USE_GLIB
-#include <utils/Log.h>
-#endif /* USE_GLIB */
-
-/* Logging Improvement */
-#include "platform_lib_includes.h"
-/*Maximum number of Modem init*/
-#define RPC_TRY_NUM 10
-
-/*Maximum number of Modem init*/
-#define RPC_TRY_NUM 10
-
-/* Uncomment to force ALOGD messages */
-// #define ALOGD ALOGI
-
-/*=====================================================================
- External declarations
-======================================================================*/
-
-CLIENT* loc_api_clnt = NULL;
-
-/* Callback ID and pointer */
-#define LOC_API_CB_MAX_CLIENTS 16
-typedef struct
-{
- uint32 cb_id; /* same as rpc/types.h */
- loc_event_cb_f_type *cb_func; /* callback func */
- loc_reset_notif_cb_f_type *rpc_cb; /* callback from RPC */
- rpc_loc_client_handle_type handle; /* stores handle for client closing */
- void* user; /* user's own data handle */
-} loc_glue_cb_entry_s_type;
-
-loc_glue_cb_entry_s_type loc_glue_callback_table[LOC_API_CB_MAX_CLIENTS];
-
-#define RPC_FUNC_VERSION_BASE(a,b) a ## b
-#define RPC_FUNC_VERSION(a,b) RPC_FUNC_VERSION_BASE(a,b)
-
-#define RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b) a ## v ## b
-#define RPC_CALLBACK_FUNC_VERSION(a,v,b) RPC_CALLBACK_FUNC_VERSION_BASE(a,v,b)
-
-#define LOC_GLUE_CHECK_INIT(ret_type) \
- if (loc_api_clnt == NULL) { EXIT_LOG_CALLFLOW(%d, RPC_LOC_API_RPC_FAILURE); return (ret_type) RPC_LOC_API_RPC_FAILURE; }
-
-#define LOC_GLUE_CHECK_RESULT(stat, ret_type) \
- if (stat != RPC_SUCCESS) { \
- LOC_LOGE("%s:%d] failure code %d", __func__, __LINE__, stat); \
- return (ret_type)((stat == RPC_SUBSYSTEM_RESTART) ? \
- RPC_LOC_API_RPC_MODEM_RESTART : RPC_LOC_API_RPC_FAILURE); \
- }
-
-/* Callback functions */
-/* Returns 1 if successful */
-bool_t rpc_loc_event_cb_f_type_svc(
- rpc_loc_event_cb_f_type_args *argp,
- rpc_loc_event_cb_f_type_rets *ret,
- struct svc_req *req)
-{
- // The lower word of cd_id is the index
- int index = argp->cb_id & 0xFFFF;
-
- /* Callback not registered, or unexpected ID (shouldn't happen) */
- if (index >= LOC_API_CB_MAX_CLIENTS || loc_glue_callback_table[index].cb_func == NULL)
- {
- LOC_LOGE("Warning: No callback handler %d.\n", index);
- ret->loc_event_cb_f_type_result = 0;
- return 1; /* simply return */
- }
-
- LOC_LOGV("proc: %x prog: %x vers: %x\n",
- (int) req->rq_proc,
- (int) req->rq_prog,
- (int) req->rq_vers);
-
- LOC_LOGV("Callback received: %x (cb_id=%p handle=%d ret_ptr=%d)\n",
- (int) argp->loc_event,
- argp->cb_id,
- (int) argp->loc_handle,
- (int) ret);
-
- /* Forward callback to real callback procedure */
- rpc_loc_client_handle_type loc_handle = argp->loc_handle;
- rpc_loc_event_mask_type loc_event = argp->loc_event;
- const rpc_loc_event_payload_u_type* loc_event_payload =
- (const rpc_loc_event_payload_u_type*) argp->loc_event_payload;
-
- /* Gives control to synchronous call handler */
- loc_api_callback_process_sync_call(loc_handle, loc_event, loc_event_payload);
-
- int32 rc = (loc_glue_callback_table[index].cb_func)(loc_glue_callback_table[index].user,
- loc_handle, loc_event, loc_event_payload);
-
- LOC_LOGV("cb_func=%p", loc_glue_callback_table[index].cb_func);
-
- ret->loc_event_cb_f_type_result = rc;
-
- return 1; /* ok */
-}
-
-int loc_apicbprog_freeresult (SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result)
-{
- xdr_free (xdr_result, result);
-
- /*
- * Insert additional freeing code here, if needed
- */
- // LOC_LOGD("***** loc_apicbprog_freeresult\n");
-
- return 1;
-}
-
-/*===========================================================================
-
-FUNCTION rpc_loc_event_cb_f_type_<version>_svc (MACRO)
-
-DESCRIPTION
- Callback function for Loc API
-
-RETURN VALUE
- 1 for success
- 0 for failure
-
-===========================================================================*/
-bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_event_cb_f_type_, RPC_LOC_EVENT_CB_F_TYPE_VERSION, _svc) (
- rpc_loc_event_cb_f_type_args *argp,
- rpc_loc_event_cb_f_type_rets *ret,
- struct svc_req *req)
-{
- return rpc_loc_event_cb_f_type_svc(argp, ret, req);
-}
-
-/*===========================================================================
-
-FUNCTION loc_apicbprog_<version>_freeresult (MACRO)
-
-DESCRIPTION
- Free up RPC data structure
-
-RETURN VALUE
- 1 for success
- 0 for failure
-
-===========================================================================*/
-#define VERSION_CONCAT(MAJOR,MINOR) MAJOR##MINOR
-#define loc_apicb_prog_VER_freeresult(M,N) \
-int RPC_CALLBACK_FUNC_VERSION(loc_apicbprog_, VERSION_CONCAT(M,N), _freeresult) \
-(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t result) \
-{ \
- return loc_apicbprog_freeresult(transp, xdr_result, result); \
-}
-
-/* Define all of the possible minors */
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0001);
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0002);
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0003);
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0004);
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0005);
-loc_apicb_prog_VER_freeresult(RPC_LOC_API_API_MAJOR_NUM, 0006);
-
-/*===========================================================================
-
-FUNCTION rpc_loc_api_cb_null_<version>_svc (MACRO) [Patch for wrong RPCGEN stubs]
-
-DESCRIPTION
- Null callback function for Loc API
-
-RETURN VALUE
- 1 for success
-
-===========================================================================*/
-#define rpc_loc_api_cb_null_VER_svc(M,N) \
-bool_t RPC_CALLBACK_FUNC_VERSION(rpc_loc_api_cb_null_, VERSION_CONCAT(M,N), _svc) ( \
- void *a, int *b, struct svc_req *req) \
-{ \
- return 1; \
-}
-
-/* Define all of the possible minors */
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0001);
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0002);
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0003);
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0004);
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0005);
-rpc_loc_api_cb_null_VER_svc(RPC_LOC_API_API_MAJOR_NUM, 0006);
-
-static void loc_api_glue_rpc_cb(CLIENT* client, enum rpc_reset_event event)
-{
- int i;
- for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++) {
- if (NULL != loc_glue_callback_table[i].rpc_cb) {
- loc_glue_callback_table[i].rpc_cb(loc_glue_callback_table[i].user, client, event);
- }
- }
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_glue_init
-
-DESCRIPTION
- Initiates the RPC client
-
-RETURN VALUE
- 1 for success
- 0 for failure
-
-===========================================================================*/
-int loc_api_glue_init(void)
-{
- if (loc_api_clnt == NULL)
- {
- /* Initialize data */
- int i;
- int pid = getpid();
- for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
- {
- loc_glue_callback_table[i].cb_id = i | (pid << 16);
- loc_glue_callback_table[i].cb_func = NULL;
- loc_glue_callback_table[i].handle = -1;
- loc_glue_callback_table[i].rpc_cb = NULL;
- loc_glue_callback_table[i].user = NULL;
- }
-
- /* Print msg */
- LOC_LOGV("Trying to create RPC client...\n");
- loc_api_clnt = clnt_create(NULL, LOC_APIPROG, LOC_APIVERS, NULL);
- LOC_LOGV("Created loc_api_clnt ---- %x\n", (unsigned int)loc_api_clnt);
-
- if (loc_api_clnt == NULL)
- {
- LOC_LOGE("Error: cannot create RPC client.\n");
- return 0;
- }
-
- /* Init RPC callbacks */
- loc_api_sync_call_init();
-
- int rc = loc_apicb_app_init();
- if (rc >= 0)
- {
- LOC_LOGD("Loc API RPC client initialized.\n");
- clnt_register_reset_notification_cb(loc_api_clnt, loc_api_glue_rpc_cb);
- }
- else {
- LOC_LOGE("Loc API callback initialization failed.\n");
- return 0;
- }
- }
-
- return 1;
-}
-
-rpc_loc_client_handle_type loc_open (
- rpc_loc_event_mask_type event_reg_mask,
- loc_event_cb_f_type *event_callback,
- loc_reset_notif_cb_f_type *rpc_cb,
- void* userData
-)
-{
- int try_num = RPC_TRY_NUM;
- ENTRY_LOG();
- LOC_GLUE_CHECK_INIT(rpc_loc_client_handle_type);
-
- rpc_loc_client_handle_type ret_val;
-
- rpc_loc_open_args args;
- args.event_reg_mask = event_reg_mask;
-
- int i, j = LOC_API_CB_MAX_CLIENTS;
- for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
- {
- if (loc_glue_callback_table[i].user == userData)
- {
- LOC_LOGW("Client already opened service (callback=%p)...\n",
- event_callback);
- break;
- } else if (j == LOC_API_CB_MAX_CLIENTS &&
- loc_glue_callback_table[i].user == NULL) {
- j = i;
- }
- }
-
- if (i == LOC_API_CB_MAX_CLIENTS)
- {
- i = j;
- }
-
- if (i == LOC_API_CB_MAX_CLIENTS)
- {
- LOC_LOGE("Too many clients opened at once...\n");
- return RPC_LOC_CLIENT_HANDLE_INVALID;
- }
-
- loc_glue_callback_table[i].cb_func = event_callback;
- loc_glue_callback_table[i].rpc_cb = rpc_cb;
- loc_glue_callback_table[i].user = userData;
-
- args.event_callback = loc_glue_callback_table[i].cb_id;
- LOC_LOGV("cb_id=%d, func=0x%x", i, (unsigned int) event_callback);
-
- rpc_loc_open_rets rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- EXIT_LOG_CALLFLOW(%s, "loc client open");
-
- /*try more for rpc_loc_open_xx()*/
-
- do
- {
- stat = RPC_FUNC_VERSION(rpc_loc_open_, RPC_LOC_OPEN_VERSION)(&args, &rets, loc_api_clnt);
- ret_val = (rpc_loc_client_handle_type) rets.loc_open_result;
- try_num--;
-
- }while( (RPC_SUCCESS != stat||0 > ret_val) && 0 != try_num );
-
- LOC_GLUE_CHECK_RESULT(stat, int32);
-
- /* save the handle in the table */
- loc_glue_callback_table[i].handle = (rpc_loc_client_handle_type) rets.loc_open_result;
-
- return ret_val;
-
-}
-
-int32 loc_close
-(
- rpc_loc_client_handle_type handle
-)
-{
- ENTRY_LOG();
- LOC_GLUE_CHECK_INIT(int32);
-
- int32 ret_val;
-
- rpc_loc_close_args args;
- args.handle = handle;
-
- rpc_loc_close_rets rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- EXIT_LOG_CALLFLOW(%s, "loc client close");
- stat = RPC_FUNC_VERSION(rpc_loc_close_, RPC_LOC_CLOSE_VERSION)(&args, &rets, loc_api_clnt);
-
- loc_clear(handle);
-
- LOC_GLUE_CHECK_RESULT(stat, int32);
- ret_val = (int32) rets.loc_close_result;
-
- return ret_val;
-}
-
-void loc_clear(rpc_loc_client_handle_type handle) {
- /* Clean the client's callback function in callback table */
- int i;
- for (i = 0; i < LOC_API_CB_MAX_CLIENTS; i++)
- {
- if (loc_glue_callback_table[i].handle == handle)
- {
- /* Found the client */
- loc_glue_callback_table[i].cb_func = NULL;
- loc_glue_callback_table[i].rpc_cb = NULL;
- loc_glue_callback_table[i].handle = -1;
- loc_glue_callback_table[i].user = NULL;
- break;
- }
- }
-
- if (i == LOC_API_CB_MAX_CLIENTS)
- {
- LOC_LOGW("Handle not found (handle=%d)...\n", (int) handle);
- }
-}
-
-int32 loc_start_fix
-(
- rpc_loc_client_handle_type handle
-)
-{
- ENTRY_LOG();
- LOC_GLUE_CHECK_INIT(int32);
-
- int32 ret_val;
-
- rpc_loc_start_fix_args args;
- args.handle = handle;
-
- rpc_loc_start_fix_rets rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- EXIT_LOG_CALLFLOW(%s, "loc start fix");
- stat = RPC_FUNC_VERSION(rpc_loc_start_fix_, RPC_LOC_START_FIX_VERSION)(&args, &rets, loc_api_clnt);
- LOC_GLUE_CHECK_RESULT(stat, int32);
-
- ret_val = (int32) rets.loc_start_fix_result;
-
- return ret_val;
-}
-
-int32 loc_stop_fix
-(
- rpc_loc_client_handle_type handle
-)
-{
- ENTRY_LOG();
- LOC_GLUE_CHECK_INIT(int32);
-
- int32 ret_val;
-
- rpc_loc_stop_fix_args args;
- args.handle = handle;
-
- rpc_loc_stop_fix_rets rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- EXIT_LOG_CALLFLOW(%s, "loc stop fix");
- stat = RPC_FUNC_VERSION(rpc_loc_stop_fix_, RPC_LOC_STOP_FIX_VERSION)(&args, &rets, loc_api_clnt);
- LOC_GLUE_CHECK_RESULT(stat, int32);
-
- ret_val = (int32) rets.loc_stop_fix_result;
-
- return ret_val;
-}
-
-int32 loc_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data
-)
-{
- ENTRY_LOG();
- LOC_GLUE_CHECK_INIT(int32);
-
- int32 ret_val;
-
- rpc_loc_ioctl_args args;
- args.handle = handle;
- args.ioctl_data = ioctl_data;
- args.ioctl_type = ioctl_type;
- if (ioctl_data != NULL)
- {
- /* Assign ioctl union discriminator */
- ioctl_data->disc = ioctl_type;
-
- /* In case the user hasn't filled in other disc fields,
- automatically fill them in here */
- switch (ioctl_type)
- {
- case RPC_LOC_IOCTL_GET_API_VERSION:
- break;
- case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
- break;
- case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
- break;
- case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
- break;
- case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
- break;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
- break;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
- break;
- case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
- break;
- case RPC_LOC_IOCTL_INJECT_UTC_TIME:
- break;
- case RPC_LOC_IOCTL_INJECT_RTC_VALUE:
- break;
- case RPC_LOC_IOCTL_INJECT_POSITION:
- break;
- case RPC_LOC_IOCTL_QUERY_ENGINE_STATE:
- break;
- case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
- break;
- case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
- break;
- case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
- break;
- case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
- break;
- case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
- break;
- case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
- break;
- case RPC_LOC_IOCTL_SET_NMEA_TYPES:
- break;
- case RPC_LOC_IOCTL_GET_NMEA_TYPES:
- break;
- case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
- args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_info.disc =
- args.ioctl_data->rpc_loc_ioctl_data_u_type_u.server_addr.addr_type;
- break;
- case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
- break;
- case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
- break;
- case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
- break;
- case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
- break;
- default:
- break;
- } /* switch */
- } /* ioctl_data != NULL */
-
- rpc_loc_ioctl_rets rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- EXIT_LOG_CALLFLOW(%s, loc_get_ioctl_type_name(ioctl_type));
- stat = RPC_FUNC_VERSION(rpc_loc_ioctl_, RPC_LOC_IOCTL_VERSION)(&args, &rets, loc_api_clnt);
- LOC_GLUE_CHECK_RESULT(stat, int32);
-
- ret_val = (int32) rets.loc_ioctl_result;
-
- return ret_val;
-}
-
-/* Returns 0 if error */
-int32 loc_api_null(void)
-{
- LOC_GLUE_CHECK_INIT(int32);
-
- int32 rets;
- enum clnt_stat stat = RPC_SUCCESS;
-
- clnt_unregister_reset_notification_cb(loc_api_clnt);
- stat = RPC_FUNC_VERSION(rpc_loc_api_null_, RPC_LOC_API_NULL_VERSION)(NULL, &rets, loc_api_clnt);
- LOC_GLUE_CHECK_RESULT(stat, int32);
-
- return (int32) rets;
-}
-
-/*===========================================================================
-
-FUNCTION loc_eng_ioctl
-
-DESCRIPTION
- This function calls loc_ioctl and waits for the callback result before
- returning back to the user.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- TRUE if successful
- FALSE if failed
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
- uint32 timeout_msec,
- rpc_loc_ioctl_callback_s_type *cb_data_ptr
-)
-{
- int ret_val = RPC_LOC_API_SUCCESS;
-
- ret_val = loc_api_sync_ioctl(handle, ioctl_type, ioctl_data_ptr, timeout_msec, cb_data_ptr);
-
- LOC_LOGD("loc_eng_ioctl result: client = %d, ioctl_type = %s, returt %s\n",
- (int32) handle,
- loc_get_ioctl_type_name(ioctl_type),
- loc_get_ioctl_status_name(ret_val) );
-
- return ret_val;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c
deleted file mode 100644
index ae629d7..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_api_sync_call.c
+++ /dev/null
@@ -1,565 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <assert.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <string.h>
-#include <pthread.h>
-
-#include <rpc/rpc.h>
-#include <loc_api_rpc_glue.h>
-#include "loc_api_sync_call.h"
-
-/* Logging */
-#define LOG_TAG "LocSvc_api_rpc_glue"
-// #define LOG_NDDEBUG 0
-#ifndef USE_GLIB
-#include <utils/Log.h>
-#endif /* USE_GLIB */
-
-/***************************************************************************
- * DATA FOR ASYNCHRONOUS RPC PROCESSING
- **************************************************************************/
-loc_sync_call_slot_array_s_type loc_sync_data;
-
-pthread_mutex_t loc_sync_call_mutex = PTHREAD_MUTEX_INITIALIZER;
-boolean loc_sync_call_inited = 0;
-
-/*===========================================================================
-
-FUNCTION loc_api_sync_call_init
-
-DESCRIPTION
- Initialize this module
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- none
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_api_sync_call_init()
-{
- pthread_mutex_lock(&loc_sync_call_mutex);
- if (loc_sync_call_inited == 1) {
- pthread_mutex_unlock(&loc_sync_call_mutex);
- return;
- }
- loc_sync_call_inited = 1;
-
- loc_sync_data.num_of_slots = LOC_SYNC_CALL_SLOTS_MAX;
-
- int i;
- for (i = 0; i < loc_sync_data.num_of_slots; i++)
- {
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
-
- pthread_mutex_init(&slot->lock, NULL);
- pthread_cond_init(&slot->loc_cb_arrived_cond, NULL);
-
- slot->not_available = 0;
- slot->in_use = 0;
- slot->loc_handle = -1;
- slot->loc_cb_wait_event_mask = 0; /* event to wait */
- slot->loc_cb_received_event_mask = 0; /* received event */
- }
-
- pthread_mutex_unlock(&loc_sync_call_mutex);
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_sync_call_destroy
-
-DESCRIPTION
- Initialize this module
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- none
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_api_sync_call_destroy()
-{
- int i;
-
- pthread_mutex_lock(&loc_sync_call_mutex);
- if (loc_sync_call_inited == 0) {
- pthread_mutex_unlock(&loc_sync_call_mutex);
- return;
- }
- loc_sync_call_inited = 0;
-
- for (i = 0; i < loc_sync_data.num_of_slots; i++)
- {
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
-
- pthread_mutex_lock(&slot->lock);
-
- slot->not_available = 1;
-
- pthread_mutex_unlock(&slot->lock);
-
- pthread_cond_destroy(&slot->loc_cb_arrived_cond);
- pthread_mutex_destroy(&slot->lock);
- }
-
- pthread_mutex_unlock(&loc_sync_call_mutex);
-}
-
-/*===========================================================================
-
-FUNCTION loc_match_callback
-
-DESCRIPTION
- Checks if an awaited event has arrived
-
-RETURN VALUE
- TRUE arrived
- FALSE not matching
-
-===========================================================================*/
-static boolean loc_match_callback(
- rpc_loc_event_mask_type wait_mask,
- rpc_loc_ioctl_e_type wait_ioctl,
- rpc_loc_event_mask_type event_mask,
- const rpc_loc_event_payload_u_type *callback_payload
-)
-{
- if ((event_mask & wait_mask) == 0) return FALSE;
-
- if (event_mask != RPC_LOC_EVENT_IOCTL_REPORT || wait_ioctl == 0 ||
- ( (callback_payload != NULL) &&
- callback_payload->rpc_loc_event_payload_u_type_u.ioctl_report.type == wait_ioctl) )
- return TRUE;
-
- return FALSE;
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_callback_process_sync_call
-
-DESCRIPTION
- Wakes up blocked API calls to check if the needed callback has arrived
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- none
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_api_callback_process_sync_call(
- rpc_loc_client_handle_type loc_handle, /* handle of the client */
- rpc_loc_event_mask_type loc_event, /* event mask */
- const rpc_loc_event_payload_u_type* loc_event_payload /* payload */
-)
-{
- int i;
-
- ALOGV("loc_handle = 0x%lx, loc_event = 0x%lx", loc_handle, loc_event);
- for (i = 0; i < loc_sync_data.num_of_slots; i++)
- {
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
-
- pthread_mutex_lock(&slot->lock);
-
- if (slot->in_use &&
- slot->signal_sent == 0 &&
- slot->loc_handle == loc_handle &&
- loc_match_callback(slot->loc_cb_wait_event_mask, slot->ioctl_type, loc_event, loc_event_payload))
- {
- memcpy(&slot->loc_cb_received_payload, loc_event_payload, sizeof (rpc_loc_event_payload_u_type));
-
- slot->loc_cb_received_event_mask = loc_event;
-
- ALOGV("signal slot %d in_use %d, loc_handle 0x%lx, event_mask 0x%1x, ioctl_type %d", i, slot->in_use, slot->loc_handle, (int) slot->loc_cb_wait_event_mask, (int) slot->ioctl_type);
- pthread_cond_signal(&slot->loc_cb_arrived_cond);
- slot->signal_sent = 1;
-
- pthread_mutex_unlock(&slot->lock);
- break;
- } else {
- /* do nothing */
- }
-
- pthread_mutex_unlock(&slot->lock);
- }
-}
-
-/*===========================================================================
-
-FUNCTION loc_lock_a_slot
-
-DESCRIPTION
- Allocates a buffer slot for the synchronous API call
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- Select ID (>=0) : successful
- -1 : buffer full
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_lock_a_slot()
-{
- int i, select_id = -1; /* no free buffer */
-
- for (i = 0; i < loc_sync_data.num_of_slots; i++)
- {
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[i];
- if (pthread_mutex_trylock(&slot->lock) == EBUSY)
- {
- ALOGV("trylock EBUSY : %d", i);
- continue;
- }
-
- if (!slot->in_use && !slot->not_available)
- {
- select_id = i;
- /* Return from here and leave the mutex locked.
- * will unlock it in loc_unlock_slot()
- */
- break;
- }
- /* ALOGV("slot %d in_use = %d, not_available = %d : %d", i, slot->in_use, slot->not_available, i); */
- pthread_mutex_unlock(&slot->lock);
- }
-
- return select_id;
-}
-
-/*===========================================================================
-
-FUNCTION loc_unlock_slot
-
-DESCRIPTION
- Unlocks a buffer slot
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_unlock_slot(int select_id)
-{
- pthread_mutex_unlock(&loc_sync_data.slots[select_id].lock);
-}
-
-/*===========================================================================
-
-FUNCTION loc_lock_slot
-
-DESCRIPTION
- Locks a specific slot that was previously locked from loc_lock_a_slot
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_lock_slot(int select_id)
-{
- pthread_mutex_lock(&loc_sync_data.slots[select_id].lock);
-}
-
-/*===========================================================================
-
-FUNCTION loc_set_slot_in_use
-
-DESCRIPTION
- Sets the in_use flag of slot to true or false.
- Should be called only after the slot is locked
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_set_slot_in_use(int select_id, boolean in_use)
-{
- loc_sync_data.slots[select_id].in_use = in_use;
- if (in_use == 1)
- loc_sync_data.slots[select_id].signal_sent = 0;
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_save_callback
-
-DESCRIPTION
- Selects which callback or IOCTL event to wait for.
-
- The event_mask specifies the event(s). If it is RPC_LOC_EVENT_IOCTL_REPORT,
- then ioctl_type specifies the IOCTL event.
-
- If ioctl_type is non-zero, RPC_LOC_EVENT_IOCTL_REPORT is automatically added.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- Select ID (>=0) : successful
- -1 : out of buffer
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_api_save_callback(
- int select_id, /* Selected slot */
- rpc_loc_client_handle_type loc_handle, /* Client handle */
- rpc_loc_event_mask_type event_mask, /* Event mask to wait for */
- rpc_loc_ioctl_e_type ioctl_type /* IOCTL type to wait for */
-)
-{
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
-
- slot->loc_handle = loc_handle;
-
- slot->loc_cb_wait_event_mask = event_mask;
- slot->ioctl_type = ioctl_type;
- if (ioctl_type) slot->loc_cb_wait_event_mask |= RPC_LOC_EVENT_IOCTL_REPORT;
-
- return;
-}
-
-/*===========================================================================
-
-FUNCTION loc_save_user_payload
-
-DESCRIPTION
- Saves received payload into user data structures
-
-RETURN VALUE
- None
-
-===========================================================================*/
-static void loc_save_user_payload(
- rpc_loc_event_payload_u_type *user_cb_payload,
- rpc_loc_ioctl_callback_s_type *user_ioctl_buffer,
- const rpc_loc_event_payload_u_type *received_cb_payload
-)
-{
- if (user_cb_payload)
- {
- memcpy(user_cb_payload, received_cb_payload,
- sizeof (rpc_loc_event_payload_u_type));
- }
- if (user_ioctl_buffer)
- {
- memcpy(user_ioctl_buffer,
- &received_cb_payload->rpc_loc_event_payload_u_type_u.ioctl_report,
- sizeof *user_ioctl_buffer);
- }
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_wait_callback
-
-DESCRIPTION
- Waits for a selected callback. The wait expires in timeout_seconds seconds.
-
- If the function is called before an existing wait has finished, it will
- immediately return EBUSY.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- RPC_LOC_API_SUCCESS if successful (0)
- RPC_LOC_API_TIMEOUT if timed out
- RPC_LOC_API_ENGINE_BUSY if already in a wait
- RPC_LOC_API_INVALID_PARAMETER if callback is not yet selected
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_api_wait_callback(
- int select_id, /* ID from loc_select_callback() */
- int timeout_seconds, /* Timeout in this number of seconds */
- rpc_loc_event_payload_u_type *callback_payload, /* Pointer to callback payload buffer, can be NULL */
- rpc_loc_ioctl_callback_s_type *ioctl_payload /* Pointer to IOCTL payload, can be NULL */
-)
-{
- int ret_val = RPC_LOC_API_SUCCESS; /* the return value of this function: 0 = no error */
- int rc = 0; /* return code from pthread calls */
-
- struct timespec expire_time;
-
- loc_sync_call_slot_s_type *slot = &loc_sync_data.slots[select_id];
-
- clock_gettime(CLOCK_REALTIME, &expire_time);
- expire_time.tv_sec += timeout_seconds;
-
- /* Waiting */
- while (slot->signal_sent == 0 && rc != ETIMEDOUT) {
- rc = pthread_cond_timedwait(&slot->loc_cb_arrived_cond,
- &slot->lock, &expire_time);
- }
-
- if (rc == ETIMEDOUT)
- {
- ret_val = RPC_LOC_API_TIMEOUT; /* Timed out */
- ALOGE("TIMEOUT: %d", select_id);
- }
- else {
- /* Obtained the first awaited callback */
- ret_val = RPC_LOC_API_SUCCESS; /* Successful */
- loc_save_user_payload(callback_payload, ioctl_payload, &slot->loc_cb_received_payload);
- }
-
- return ret_val;
-}
-
-/*===========================================================================
-
-FUNCTION loc_api_sync_ioctl
-
-DESCRIPTION
- Synchronous IOCTL call (reentrant version)
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- Loc API error code (0 = success)
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_api_sync_ioctl
-(
- rpc_loc_client_handle_type handle,
- rpc_loc_ioctl_e_type ioctl_type,
- rpc_loc_ioctl_data_u_type* ioctl_data_ptr,
- uint32 timeout_msec,
- rpc_loc_ioctl_callback_s_type *cb_data_ptr
-)
-{
- int rc = -1;
- int select_id;
- rpc_loc_ioctl_callback_s_type callback_data;
-
- select_id = loc_lock_a_slot();
-
- if (select_id < 0 || select_id >= loc_sync_data.num_of_slots)
- {
- ALOGE("slot not available ioctl_type = %s",
- loc_get_ioctl_type_name(ioctl_type));
- return rc;
- }
-
- loc_set_slot_in_use(select_id, 1); // set slot in use to true
-
- // Select the callback we are waiting for
- loc_api_save_callback(select_id, handle, 0, ioctl_type);
-
- loc_unlock_slot(select_id); // slot is unlocked, but in_use is still true
-
- // we want to avoid keeping the slot locked during the loc_ioctl because the rpc
- // framework will also lock a different mutex during this call, and typically
- // locking two different mutexes at the same time can lead to deadlock.
- rc = loc_ioctl(handle, ioctl_type, ioctl_data_ptr);
-
- loc_lock_slot(select_id);
-
- if (rc != RPC_LOC_API_SUCCESS)
- {
- ALOGE("loc_ioctl failed select_id = %d, ioctl_type %s, returned %s",
- select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
- }
- else {
- ALOGV("select_id = %d, ioctl_type %d, returned RPC_LOC_API_SUCCESS",
- select_id, ioctl_type);
- // Wait for the callback of loc_ioctl
- if ((rc = loc_api_wait_callback(select_id, timeout_msec / 1000, NULL, &callback_data)) != 0)
- {
- // Callback waiting failed
- ALOGE("callback wait failed select_id = %d, ioctl_type %s, returned %s",
- select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
- }
- else
- {
- if (cb_data_ptr) memcpy(cb_data_ptr, &callback_data, sizeof *cb_data_ptr);
- if (callback_data.status != RPC_LOC_API_SUCCESS)
- {
- rc = callback_data.status;
- ALOGE("callback status failed select_id = %d, ioctl_type %s, returned %s",
- select_id, loc_get_ioctl_type_name(ioctl_type), loc_get_ioctl_status_name(rc));
- } else {
- ALOGV("callback status success select_id = %d, ioctl_type %d, returned %d",
- select_id, ioctl_type, rc);
- }
- } /* wait callback */
- } /* loc_ioctl */
-
- loc_set_slot_in_use(select_id, 0); // set slot in use to false
- loc_unlock_slot(select_id);
-
- return rc;
-}
-
-
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c
deleted file mode 100644
index db5b291..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-glue/src/loc_apicb_appinit.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "rpc/rpc.h"
-
-/* Include RPC headers */
-#ifdef USE_LOCAL_RPC
-#include "rpc_inc/loc_api_common.h"
-#include "rpc_inc/loc_api.h"
-#include "rpc_inc/loc_api_cb.h"
-#endif
-
-#ifdef USE_QCOM_AUTO_RPC
-#include "loc_api_rpcgen_rpc.h"
-#include "loc_api_rpcgen_common_rpc.h"
-#include "loc_api_rpcgen_cb_rpc.h"
-#endif
-
-#include "rpc_inc/loc_api_fixup.h"
-#include "loc_apicb_appinit.h"
-
-#define RPC_FUNC_VERSION_BASE(a,b) a ## b
-#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
-
-static SVCXPRT* svrPort = NULL;
-
-extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
-
-int loc_apicb_app_init(void)
-{
-
- /* Register a callback server to use the loc_apicbprog_* function */
- if (svrPort == NULL) {
- svrPort = svcrtr_create();
- }
- if (!svrPort) return -1;
-
- xprt_register(svrPort);
- if(svc_register(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
- {
- return 0;
- }
- else
- {
- return -1;
- }
-}
-
-void loc_apicb_app_deinit(void)
-{
- if (svrPort == NULL)
- {
- return;
- }
-
- svc_unregister(svrPort, LOC_APICBPROG, LOC_APICBVERS_0001);
- xprt_unregister(svrPort);
- svc_destroy(svrPort);
- svrPort = NULL;
-}
-
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
deleted file mode 100644
index c0987e6..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Android.mk
+++ /dev/null
@@ -1,36 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-# functions
-LOC_RPCGEN_APIS_PATH := $(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
-LOC_RPCGEN_APIS_PATH_FL := ../../../../../$(TARGET_OUT_INTERMEDIATES)/loc_api/libloc_api_rpcgen_intermediates
-
-LOCAL_MODULE := libloc_api_rpcgen
-LOCAL_MODULE_OWNER := qcom
-
-LOCAL_SHARED_LIBRARIES := \
- librpc \
- libcommondefs
-
-LOCAL_SRC_FILES += \
- src/loc_api_rpcgen_cb_xdr.c \
- src/loc_api_rpcgen_common_xdr.c \
- src/loc_api_rpcgen_cb_svc.c \
- src/loc_api_rpcgen_clnt.c \
- src/loc_api_rpcgen_xdr.c
-
-LOCAL_C_INCLUDES += hardware/msm7k/librpc
-LOCAL_C_INCLUDES += $(LOC_RPCGEN_APIS_PATH)/../../SHARED_LIBRARIES/libcommondefs_intermediates/inc
-LOCAL_C_INCLUDES += $(LOCAL_PATH)/inc
-LOCAL_C_INCLUDES += $(TARGET_OUT_HEADERS)/libcommondefs/rpcgen/inc
-
-LOCAL_COPY_HEADERS_TO := loc_api/rpcgen/inc
-LOCAL_COPY_HEADERS := inc/loc_api_rpcgen_rpc.h
-LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_common_rpc.h
-LOCAL_COPY_HEADERS += inc/loc_api_rpcgen_cb_rpc.h
-LOCAL_COPY_HEADERS += inc/loc_apicb_appinit.h
-
-LOCAL_LDLIBS += -lpthread
-LOCAL_PRELINK_MODULE := false
-include $(BUILD_STATIC_LIBRARY)
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am
deleted file mode 100644
index 486fadf..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/Makefile.am
+++ /dev/null
@@ -1,42 +0,0 @@
-AM_CFLAGS = \
- -I../../../utils \
- -I./inc \
- $(MSM7K_CFLAGS)
-
-requiredlibs = \
- ../../../utils/libgps_utils_so.la \
- $(MSM7K_LIBS)
-
-h_sources = \
- inc/loc_api_rpcgen_rpc.h \
- inc/loc_api_rpcgen_common_rpc.h \
- inc/loc_api_rpcgen_cb_rpc.h \
- inc/loc_apicb_appinit.h
-
-c_sources = \
- src/loc_api_rpcgen_cb_xdr.c \
- src/loc_api_rpcgen_common_xdr.c \
- src/loc_api_rpcgen_cb_svc.c \
- src/loc_api_rpcgen_clnt.c \
- src/loc_api_rpcgen_xdr.c
-
-
-
-library_includedir = $(pkgincludedir)/libloc_api-rpc-50001/libloc_api-rpc-stub/inc
-library_include_HEADERS = $(h_sources)
-libloc_api_rpcgen_la_SOURCES = $(c_sources) $(h_sources)
-
-if USE_GLIB
-libloc_api_rpcgen_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_api_rpcgen_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_api_rpcgen_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_api_rpcgen_la_CFLAGS = $(AM_CFLAGS)
-libloc_api_rpcgen_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_api_rpcgen_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-
-libloc_api_rpcgen_la_LIBADD = $(requiredlibs) -lstdc++
-
-#Create and Install Libraries
-lib_LTLIBRARIES = libloc_api_rpcgen.la
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h
deleted file mode 100644
index 87f2c37..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_cb_rpc.h
+++ /dev/null
@@ -1,156 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#ifndef _LOC_API_CB_RPC_H_RPCGEN
-#define _LOC_API_CB_RPC_H_RPCGEN
-
-#include "librpc.h"
-#include "commondefs_rpcgen_rpc.h"
-#include "loc_api_rpcgen_common_rpc.h"
-
-#include <pthread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-struct rpc_loc_event_cb_f_type_args {
- rpc_uint32 cb_id;
- rpc_loc_client_handle_type loc_handle;
- rpc_loc_event_mask_type loc_event;
- rpc_loc_event_payload_u_type *loc_event_payload;
-};
-typedef struct rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_args;
-
-struct rpc_loc_event_cb_f_type_rets {
- rpc_int32 loc_event_cb_f_type_result;
-};
-typedef struct rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_rets;
-#define LOC_APICBVERS 0x00050006
-
-#define LOC_APICBPROG 0x3100008C
-#define LOC_APICBVERS_0001 0x00050001
-
-#if defined(__STDC__) || defined(__cplusplus)
-#define rpc_loc_event_cb_f_type 1
-extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, CLIENT *);
-extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc(rpc_loc_event_cb_f_type_args *, rpc_loc_event_cb_f_type_rets *, struct svc_req *);
-extern int loc_apicbprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-#define rpc_loc_event_cb_f_type 1
-extern enum clnt_stat rpc_loc_event_cb_f_type_0x00050001();
-extern bool_t rpc_loc_event_cb_f_type_0x00050001_svc();
-extern int loc_apicbprog_0x00050001_freeresult ();
-#endif /* K&R C */
-#define LOC_APICBVERS_0002 0x00050002
-
-#if defined(__STDC__) || defined(__cplusplus)
-#define rpc_loc_api_cb_null 0xffffff00
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050002(void *, int *, CLIENT *);
-extern bool_t rpc_loc_api_cb_null_0x00050002_svc(void *, int *, struct svc_req *);
-extern int loc_apicbprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-#define rpc_loc_api_cb_null 0xffffff00
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050002();
-extern bool_t rpc_loc_api_cb_null_0x00050002_svc();
-extern int loc_apicbprog_0x00050002_freeresult ();
-#endif /* K&R C */
-#define LOC_APICBVERS_0003 0x00050003
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050003(void *, int *, CLIENT *);
-extern bool_t rpc_loc_api_cb_null_0x00050003_svc(void *, int *, struct svc_req *);
-extern int loc_apicbprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050003();
-extern bool_t rpc_loc_api_cb_null_0x00050003_svc();
-extern int loc_apicbprog_0x00050003_freeresult ();
-#endif /* K&R C */
-#define LOC_APICBVERS_0004 0x00050004
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050004(void *, int *, CLIENT *);
-extern bool_t rpc_loc_api_cb_null_0x00050004_svc(void *, int *, struct svc_req *);
-extern int loc_apicbprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050004();
-extern bool_t rpc_loc_api_cb_null_0x00050004_svc();
-extern int loc_apicbprog_0x00050004_freeresult ();
-#endif /* K&R C */
-#define LOC_APICBVERS_0005 0x00050005
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050005(void *, int *, CLIENT *);
-extern bool_t rpc_loc_api_cb_null_0x00050005_svc(void *, int *, struct svc_req *);
-extern int loc_apicbprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050005();
-extern bool_t rpc_loc_api_cb_null_0x00050005_svc();
-extern int loc_apicbprog_0x00050005_freeresult ();
-#endif /* K&R C */
-#define LOC_APICBVERS_0006 0x00050006
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050006(void *, int *, CLIENT *);
-extern bool_t rpc_loc_api_cb_null_0x00050006_svc(void *, int *, struct svc_req *);
-extern int loc_apicbprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_cb_null_0x00050006();
-extern bool_t rpc_loc_api_cb_null_0x00050006_svc();
-extern int loc_apicbprog_0x00050006_freeresult ();
-#endif /* K&R C */
-
-/* the xdr functions */
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern bool_t xdr_rpc_loc_event_cb_f_type_args (XDR *, rpc_loc_event_cb_f_type_args*);
-extern bool_t xdr_rpc_loc_event_cb_f_type_rets (XDR *, rpc_loc_event_cb_f_type_rets*);
-
-#else /* K&R C */
-extern bool_t xdr_rpc_loc_event_cb_f_type_args ();
-extern bool_t xdr_rpc_loc_event_cb_f_type_rets ();
-
-#endif /* K&R C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !_LOC_API_CB_RPC_H_RPCGEN */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h
deleted file mode 100644
index 8107de2..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_common_rpc.h
+++ /dev/null
@@ -1,1261 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#ifndef _LOC_API_COMMON_RPC_H_RPCGEN
-#define _LOC_API_COMMON_RPC_H_RPCGEN
-
-#include "librpc.h"
-#include "commondefs_rpcgen_rpc.h"
-
-#include <pthread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define LOC_API_TOOLVERS 0x00040030
-#define LOC_API_FEATURES 0x00000001
-#define RPC_LOC_EVENT_STATUS_REPORT 0x00000100
-#define RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST 0x00000020
-#define RPC_LOC_EVENT_WPS_NEEDED_REQUEST 0x00000200
-#define RPC_LOC_EVENT_SATELLITE_REPORT 0x00000002
-#define RPC_LOC_EVENT_PARSED_POSITION_REPORT 0x00000001
-#define RPC_LOC_EVENT_RESERVED 0x8000000000000000
-#define RPC_LOC_EVENT_LOCATION_SERVER_REQUEST 0x00000040
-#define RPC_LOC_EVENT_NMEA_POSITION_REPORT 0x00000008
-#define RPC_LOC_EVENT_IOCTL_REPORT 0x00000080
-#define RPC_LOC_EVENT_NMEA_1HZ_REPORT 0x00000004
-#define RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST 0x00000010
-#define RPC_LOC_API_CB_NULL_VERSION 0x00050002
-#define RPC_LOC_EVENT_CB_F_TYPE_VERSION 0x00050001
-#define RPC_LOC_API_API_VERSIONS_VERSION 0x00050001
-#define RPC_LOC_STOP_FIX_VERSION 0x00050001
-#define RPC_LOC_START_FIX_VERSION 0x00050001
-#define RPC_LOC_IOCTL_VERSION 0x00050001
-#define RPC_LOC_CLOSE_VERSION 0x00050001
-#define RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION 0x00050001
-#define RPC_LOC_OPEN_VERSION 0x00050001
-#define RPC_LOC_API_NULL_VERSION 0x00050001
-#define RPC_LOC_API_API_MAJOR_NUM 0x0005
-#define RPC_LOC_APIAPI_VERSION_IS_HASHKEY 0
-
-typedef rpc_int32 rpc_loc_client_handle_type;
-
-typedef rpc_uint64 rpc_loc_event_mask_type;
-
-typedef rpc_uint64 rpc_loc_position_valid_mask_type;
-
-typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
-
-enum rpc_loc_session_status_e_type {
- RPC_LOC_SESS_STATUS_SUCCESS = 0,
- RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
- RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
- RPC_LOC_SESS_STATUS_TIMEOUT = 3,
- RPC_LOC_SESS_STATUS_USER_END = 4,
- RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
- RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
- RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
- RPC_LOC_SESS_STATUS_MAX = 268435456,
-};
-typedef enum rpc_loc_session_status_e_type rpc_loc_session_status_e_type;
-
-struct rpc_loc_calendar_time_s_type {
- rpc_uint16 year;
- u_char month;
- u_char day_of_week;
- u_char day;
- u_char hour;
- u_char minute;
- u_char second;
- rpc_uint16 millisecond;
-};
-typedef struct rpc_loc_calendar_time_s_type rpc_loc_calendar_time_s_type;
-
-struct rpc_loc_parsed_position_s_type {
- rpc_loc_position_valid_mask_type valid_mask;
- rpc_loc_session_status_e_type session_status;
- rpc_loc_calendar_time_s_type timestamp_calendar;
- rpc_uint64 timestamp_utc;
- rpc_uint8 leap_seconds;
- float time_unc;
- double latitude;
- double longitude;
- float altitude_wrt_ellipsoid;
- float altitude_wrt_mean_sea_level;
- float speed_horizontal;
- float speed_vertical;
- float heading;
- float hor_unc_circular;
- float hor_unc_ellipse_semi_major;
- float hor_unc_ellipse_semi_minor;
- float hor_unc_ellipse_orient_azimuth;
- float vert_unc;
- float speed_unc;
- float heading_unc;
- u_char confidence_horizontal;
- u_char confidence_vertical;
- float magnetic_deviation;
- rpc_loc_pos_technology_mask_type technology_mask;
-};
-typedef struct rpc_loc_parsed_position_s_type rpc_loc_parsed_position_s_type;
-
-enum rpc_loc_sv_system_e_type {
- RPC_LOC_SV_SYSTEM_GPS = 1,
- RPC_LOC_SV_SYSTEM_GALILEO = 2,
- RPC_LOC_SV_SYSTEM_SBAS = 3,
- RPC_LOC_SV_SYSTEM_COMPASS = 4,
- RPC_LOC_SV_SYSTEM_GLONASS = 5,
- RPC_LOC_SV_SYSTEM_MAX = 268435456,
-};
-typedef enum rpc_loc_sv_system_e_type rpc_loc_sv_system_e_type;
-
-enum rpc_loc_sv_status_e_type {
- RPC_LOC_SV_STATUS_IDLE = 1,
- RPC_LOC_SV_STATUS_SEARCH = 2,
- RPC_LOC_SV_STATUS_TRACK = 3,
- RPC_LOC_SV_STATUS_MAX = 268435456,
-};
-typedef enum rpc_loc_sv_status_e_type rpc_loc_sv_status_e_type;
-
-typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
-
-struct rpc_loc_sv_info_s_type {
- rpc_loc_sv_info_valid_mask_type valid_mask;
- rpc_loc_sv_system_e_type system;
- rpc_uint8 prn;
- rpc_uint8 health_status;
- rpc_loc_sv_status_e_type process_status;
- rpc_boolean has_eph;
- rpc_boolean has_alm;
- float elevation;
- float azimuth;
- float snr;
-};
-typedef struct rpc_loc_sv_info_s_type rpc_loc_sv_info_s_type;
-
-typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
-
-struct rpc_loc_gnss_info_s_type {
- rpc_loc_gnss_info_valid_mask_type valid_mask;
- float position_dop;
- float horizontal_dop;
- float vertical_dop;
- rpc_boolean altitude_assumed;
- rpc_uint16 sv_count;
- struct {
- u_int sv_list_len;
- rpc_loc_sv_info_s_type *sv_list_val;
- } sv_list;
-};
-typedef struct rpc_loc_gnss_info_s_type rpc_loc_gnss_info_s_type;
-
-struct rpc_loc_nmea_report_s_type {
- rpc_uint16 length;
- char nmea_sentences[200];
-};
-typedef struct rpc_loc_nmea_report_s_type rpc_loc_nmea_report_s_type;
-
-enum rpc_loc_status_event_e_type {
- RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
- RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE = 2,
- RPC_LOC_STATUS_EVENT_MAX = 268435456,
-};
-typedef enum rpc_loc_status_event_e_type rpc_loc_status_event_e_type;
-
-enum rpc_loc_engine_state_e_type {
- RPC_LOC_ENGINE_STATE_ON = 1,
- RPC_LOC_ENGINE_STATE_OFF = 2,
- RPC_LOC_ENGINE_STATE_MAX = 268435456,
-};
-typedef enum rpc_loc_engine_state_e_type rpc_loc_engine_state_e_type;
-
-enum rpc_loc_fix_session_state_e_type {
- RPC_LOC_FIX_SESSION_STATE_BEGIN = 1,
- RPC_LOC_FIX_SESSION_STATE_END = 2,
- RPC_LOC_FIX_SESSION_STATE_MAX = 268435456,
-};
-typedef enum rpc_loc_fix_session_state_e_type rpc_loc_fix_session_state_e_type;
-
-struct rpc_loc_status_event_payload_u_type {
- rpc_loc_status_event_e_type disc;
- union {
- rpc_loc_engine_state_e_type engine_state;
- rpc_loc_fix_session_state_e_type fix_session_state;
- } rpc_loc_status_event_payload_u_type_u;
-};
-typedef struct rpc_loc_status_event_payload_u_type rpc_loc_status_event_payload_u_type;
-
-struct rpc_loc_status_event_s_type {
- rpc_loc_status_event_e_type event;
- rpc_loc_status_event_payload_u_type payload;
-};
-typedef struct rpc_loc_status_event_s_type rpc_loc_status_event_s_type;
-
-enum rpc_loc_server_addr_e_type {
- RPC_LOC_SERVER_ADDR_IPV4 = 1,
- RPC_LOC_SERVER_ADDR_URL = 2,
- RPC_LOC_SERVER_ADDR_IPV6 = 3,
- RPC_LOC_SERVER_ADDR_MAX = 268435456,
-};
-typedef enum rpc_loc_server_addr_e_type rpc_loc_server_addr_e_type;
-
-struct rpc_loc_server_addr_ipv4_type {
- rpc_uint32 addr;
- rpc_uint16 port;
-};
-typedef struct rpc_loc_server_addr_ipv4_type rpc_loc_server_addr_ipv4_type;
-
-struct rpc_loc_server_addr_url_type {
- rpc_uint16 length;
- char addr[256];
-};
-typedef struct rpc_loc_server_addr_url_type rpc_loc_server_addr_url_type;
-
-struct rpc_loc_server_addr_ipv6_type {
- rpc_uint16 addr[8];
- rpc_uint32 port;
-};
-typedef struct rpc_loc_server_addr_ipv6_type rpc_loc_server_addr_ipv6_type;
-
-struct rpc_loc_server_addr_u_type {
- rpc_loc_server_addr_e_type disc;
- union {
- rpc_loc_server_addr_ipv4_type ipv4;
- rpc_loc_server_addr_url_type url;
- rpc_loc_server_addr_ipv6_type ipv6;
- } rpc_loc_server_addr_u_type_u;
-};
-typedef struct rpc_loc_server_addr_u_type rpc_loc_server_addr_u_type;
-
-struct rpc_loc_server_info_s_type {
- rpc_loc_server_addr_e_type addr_type;
- rpc_loc_server_addr_u_type addr_info;
-};
-typedef struct rpc_loc_server_info_s_type rpc_loc_server_info_s_type;
-
-enum rpc_loc_ni_notify_verify_e_type {
- RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
- RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
- RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
- RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
- RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
- RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_notify_verify_e_type rpc_loc_ni_notify_verify_e_type;
-
-enum rpc_loc_ni_event_e_type {
- RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
- RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
- RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
- RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ = 4,
- RPC_LOC_NI_EVENT_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_event_e_type rpc_loc_ni_event_e_type;
-
-enum rpc_loc_ni_datacoding_scheme_e_type {
- RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
- RPC_LOC_NI_PRESUPL_ISO8859 = 1,
- RPC_LOC_NI_PRESUPL_UTF8 = 2,
- RPC_LOC_NI_PRESUPL_UTF16 = 3,
- RPC_LOC_NI_PRESUPL_UCS2 = 4,
- RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
- RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
- RPC_LOC_NI_PRESUPL_JIS = 7,
- RPC_LOC_NI_PRESUPL_EUC = 8,
- RPC_LOC_NI_PRESUPL_GB2312 = 9,
- RPC_LOC_NI_PRESUPL_CNS11643 = 10,
- RPC_LOC_NI_PRESUPL_KSC1001 = 11,
- RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
- RPC_LOC_NI_SS_GERMAN = 12,
- RPC_LOC_NI_SS_ENGLISH = 13,
- RPC_LOC_NI_SS_ITALIAN = 14,
- RPC_LOC_NI_SS_FRENCH = 15,
- RPC_LOC_NI_SS_SPANISH = 16,
- RPC_LOC_NI_SS_DUTCH = 17,
- RPC_LOC_NI_SS_SWEDISH = 18,
- RPC_LOC_NI_SS_DANISH = 19,
- RPC_LOC_NI_SS_PORTUGUESE = 20,
- RPC_LOC_NI_SS_FINNISH = 21,
- RPC_LOC_NI_SS_NORWEGIAN = 22,
- RPC_LOC_NI_SS_GREEK = 23,
- RPC_LOC_NI_SS_TURKISH = 24,
- RPC_LOC_NI_SS_HUNGARIAN = 25,
- RPC_LOC_NI_SS_POLISH = 26,
- RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
- RPC_LOC_NI_SUPL_UTF8 = 28,
- RPC_LOC_NI_SUPL_UCS2 = 29,
- RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
- RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647,
-};
-typedef enum rpc_loc_ni_datacoding_scheme_e_type rpc_loc_ni_datacoding_scheme_e_type;
-
-enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
- RPC_LOC_NI_VX_OCTET = 0,
- RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
- RPC_LOC_NI_VX_ASCII = 2,
- RPC_LOC_NI_VX_IA5 = 3,
- RPC_LOC_NI_VX_UNICODE = 4,
- RPC_LOC_NI_VX_SHIFT_JIS = 5,
- RPC_LOC_NI_VX_KOREAN = 6,
- RPC_LOC_NI_VX_LATIN_HEBREW = 7,
- RPC_LOC_NI_VX_LATIN = 8,
- RPC_LOC_NI_VX_GSM = 9,
- RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type rpc_loc_ni_vx_requester_id_encoding_scheme_e_type;
-
-enum rpc_loc_ni_vx_pos_mode_e_type {
- RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
- RPC_LOC_VX_MS_BASED_ONLY = 2,
- RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
- RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
- RPC_LOC_VX_POS_MODE_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_vx_pos_mode_e_type rpc_loc_ni_vx_pos_mode_e_type;
-
-struct rpc_loc_ni_vx_requester_id_s_type {
- u_char requester_id_length;
- char requester_id[200];
-};
-typedef struct rpc_loc_ni_vx_requester_id_s_type rpc_loc_ni_vx_requester_id_s_type;
-
-struct rpc_loc_ni_vx_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- u_char pos_qos_incl;
- u_char pos_qos;
- rpc_uint32 num_fixes;
- rpc_uint32 tbf;
- rpc_loc_ni_vx_pos_mode_e_type pos_mode;
- rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
- rpc_loc_ni_vx_requester_id_s_type requester_id;
- rpc_uint16 user_resp_timer_val;
-};
-typedef struct rpc_loc_ni_vx_notify_verify_req_s_type rpc_loc_ni_vx_notify_verify_req_s_type;
-
-enum rpc_loc_ni_supl_pos_method_e_type {
- RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
- RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
- RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
- RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
- RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
- RPC_LOC_NI_POSMETHOD_AFLT = 6,
- RPC_LOC_NI_POSMETHOD_ECID = 7,
- RPC_LOC_NI_POSMETHOD_EOTD = 8,
- RPC_LOC_NI_POSMETHOD_OTDOA = 9,
- RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
- RPC_LOC_NI_POSMETHOD_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_supl_pos_method_e_type rpc_loc_ni_supl_pos_method_e_type;
-
-struct rpc_loc_ni_supl_slp_session_id_s_type {
- u_char presence;
- char session_id[4];
- rpc_loc_server_info_s_type slp_address;
-};
-typedef struct rpc_loc_ni_supl_slp_session_id_s_type rpc_loc_ni_supl_slp_session_id_s_type;
-
-struct rpc_loc_ni_requestor_id_s_type {
- u_char data_coding_scheme;
- char requestor_id_string[200];
- u_char string_len;
-};
-typedef struct rpc_loc_ni_requestor_id_s_type rpc_loc_ni_requestor_id_s_type;
-
-struct rpc_loc_ni_supl_client_name_s_type {
- u_char data_coding_scheme;
- char client_name_string[64];
- u_char string_len;
-};
-typedef struct rpc_loc_ni_supl_client_name_s_type rpc_loc_ni_supl_client_name_s_type;
-
-struct rpc_loc_ni_supl_qop_s_type {
- u_char bit_mask;
- u_char horacc;
- u_char veracc;
- rpc_uint16 maxLocAge;
- u_char delay;
-};
-typedef struct rpc_loc_ni_supl_qop_s_type rpc_loc_ni_supl_qop_s_type;
-
-struct rpc_loc_ni_supl_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- rpc_uint16 flags;
- rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
- char supl_hash[8];
- rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
- rpc_loc_ni_supl_pos_method_e_type pos_method;
- rpc_loc_ni_requestor_id_s_type requestor_id;
- rpc_loc_ni_supl_client_name_s_type client_name;
- rpc_loc_ni_supl_qop_s_type supl_qop;
- rpc_uint16 user_response_timer;
-};
-typedef struct rpc_loc_ni_supl_notify_verify_req_s_type rpc_loc_ni_supl_notify_verify_req_s_type;
-
-struct rpc_loc_ni_ext_client_address_s_type {
- u_char ext_client_address_len;
- char ext_client_address[20];
-};
-typedef struct rpc_loc_ni_ext_client_address_s_type rpc_loc_ni_ext_client_address_s_type;
-
-enum rpc_loc_ni_location_type_e_type {
- RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
- RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
- RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
- RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_location_type_e_type rpc_loc_ni_location_type_e_type;
-
-struct rpc_loc_ni_deferred_location_s_type {
- u_char unused_bits;
- u_char ms_available;
-};
-typedef struct rpc_loc_ni_deferred_location_s_type rpc_loc_ni_deferred_location_s_type;
-
-struct rpc_loc_ni_codeword_string_s_type {
- u_char data_coding_scheme;
- char lcs_codeword_string[20];
- u_char string_len;
-};
-typedef struct rpc_loc_ni_codeword_string_s_type rpc_loc_ni_codeword_string_s_type;
-
-struct rpc_loc_ni_service_type_id_s_type {
- u_char lcs_service_type_id;
-};
-typedef struct rpc_loc_ni_service_type_id_s_type rpc_loc_ni_service_type_id_s_type;
-
-struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- u_char invoke_id;
- rpc_uint16 flags;
- u_char notification_length;
- char notification_text[64];
- rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
- rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
- rpc_loc_ni_location_type_e_type location_type;
- rpc_loc_ni_deferred_location_s_type deferred_location;
- rpc_loc_ni_requestor_id_s_type requestor_id;
- rpc_loc_ni_codeword_string_s_type codeword_string;
- rpc_loc_ni_service_type_id_s_type service_type_id;
- rpc_uint16 user_response_timer;
-};
-typedef struct rpc_loc_ni_umts_cp_notify_verify_req_s_type rpc_loc_ni_umts_cp_notify_verify_req_s_type;
-
-enum rpc_loc_ni_service_interaction_e_type {
- RPC_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO = 1,
- RPC_LOC_NI_SERVICE_INTERACTION_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_service_interaction_e_type rpc_loc_ni_service_interaction_e_type;
-
-struct rpc_loc_ni_vx_service_interaction_req_s_type {
- rpc_loc_ni_vx_notify_verify_req_s_type ni_vx_req;
- rpc_loc_ni_service_interaction_e_type service_interation_type;
-};
-typedef struct rpc_loc_ni_vx_service_interaction_req_s_type rpc_loc_ni_vx_service_interaction_req_s_type;
-
-struct rpc_loc_ni_event_payload_u_type {
- rpc_loc_ni_event_e_type disc;
- union {
- rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
- rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
- rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
- rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req;
- } rpc_loc_ni_event_payload_u_type_u;
-};
-typedef struct rpc_loc_ni_event_payload_u_type rpc_loc_ni_event_payload_u_type;
-
-struct rpc_loc_ni_event_s_type {
- rpc_loc_ni_event_e_type event;
- rpc_loc_ni_event_payload_u_type payload;
-};
-typedef struct rpc_loc_ni_event_s_type rpc_loc_ni_event_s_type;
-
-enum rpc_loc_assist_data_request_e_type {
- RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
- RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
- RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ = 3,
- RPC_LOC_ASSIST_DATA_MAX = 268435456,
-};
-typedef enum rpc_loc_assist_data_request_e_type rpc_loc_assist_data_request_e_type;
-
-typedef char *rpc_struct_loc_time_download_source_s_type_servers_ptr;
-
-typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3];
-
-struct rpc_loc_time_download_source_s_type {
- rpc_uint32 delay_threshold;
- rpc_struct_loc_time_download_source_s_type_servers servers;
-};
-typedef struct rpc_loc_time_download_source_s_type rpc_loc_time_download_source_s_type;
-
-typedef char *rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr;
-
-typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3];
-
-struct rpc_loc_predicted_orbits_data_source_s_type {
- rpc_uint32 max_file_size;
- rpc_uint32 max_part_size;
- rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
-};
-typedef struct rpc_loc_predicted_orbits_data_source_s_type rpc_loc_predicted_orbits_data_source_s_type;
-
-struct rpc_loc_pos_inj_request_s_type {
- rpc_uint32 flags;
- double latitude;
- double longitude;
- rpc_uint32 position_uncertainty;
- rpc_uint64 timestamp;
-};
-typedef struct rpc_loc_pos_inj_request_s_type rpc_loc_pos_inj_request_s_type;
-
-struct rpc_loc_assist_data_request_payload_u_type {
- rpc_loc_assist_data_request_e_type disc;
- union {
- rpc_loc_time_download_source_s_type time_download;
- rpc_loc_predicted_orbits_data_source_s_type data_download;
- rpc_loc_pos_inj_request_s_type pos_injection;
- } rpc_loc_assist_data_request_payload_u_type_u;
-};
-typedef struct rpc_loc_assist_data_request_payload_u_type rpc_loc_assist_data_request_payload_u_type;
-
-struct rpc_loc_assist_data_request_s_type {
- rpc_loc_assist_data_request_e_type event;
- rpc_loc_assist_data_request_payload_u_type payload;
-};
-typedef struct rpc_loc_assist_data_request_s_type rpc_loc_assist_data_request_s_type;
-
-typedef rpc_uint32 rpc_loc_server_connection_handle;
-
-enum rpc_loc_server_protocol_e_type {
- RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
- RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
- RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
- RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
- RPC_LOC_SERVER_PROTOCOL_MAX = 16777216,
-};
-typedef enum rpc_loc_server_protocol_e_type rpc_loc_server_protocol_e_type;
-
-enum rpc_loc_server_connection_e_type {
- RPC_LOC_SERVER_CONNECTION_LBS = 0,
- RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET = 0 + 1,
- RPC_LOC_SERVER_CONNECTION_MAX = 16777216,
-};
-typedef enum rpc_loc_server_connection_e_type rpc_loc_server_connection_e_type;
-
-enum rpc_loc_server_request_e_type {
- RPC_LOC_SERVER_REQUEST_OPEN = 1,
- RPC_LOC_SERVER_REQUEST_CLOSE = 2,
- RPC_LOC_SERVER_REQUEST_MULTI_OPEN = 3,
- RPC_LOC_SERVER_REQUEST_MAX = 268435456,
-};
-typedef enum rpc_loc_server_request_e_type rpc_loc_server_request_e_type;
-
-struct rpc_loc_server_open_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_protocol_e_type protocol;
-};
-typedef struct rpc_loc_server_open_req_s_type rpc_loc_server_open_req_s_type;
-
-struct rpc_loc_server_multi_open_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_protocol_e_type protocol;
- rpc_loc_server_connection_e_type connection_type;
-};
-typedef struct rpc_loc_server_multi_open_req_s_type rpc_loc_server_multi_open_req_s_type;
-
-struct rpc_loc_server_close_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
-};
-typedef struct rpc_loc_server_close_req_s_type rpc_loc_server_close_req_s_type;
-
-struct rpc_loc_server_request_u_type {
- rpc_loc_server_request_e_type disc;
- union {
- rpc_loc_server_open_req_s_type open_req;
- rpc_loc_server_close_req_s_type close_req;
- rpc_loc_server_multi_open_req_s_type multi_open_req;
- } rpc_loc_server_request_u_type_u;
-};
-typedef struct rpc_loc_server_request_u_type rpc_loc_server_request_u_type;
-
-struct rpc_loc_server_request_s_type {
- rpc_loc_server_request_e_type event;
- rpc_loc_server_request_u_type payload;
-};
-typedef struct rpc_loc_server_request_s_type rpc_loc_server_request_s_type;
-
-enum rpc_loc_qwip_request_e_type {
- RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0,
- RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM = 0 + 1,
- RPC_LOC_QWIP_STOP_PERIODIC_FIXES = 0 + 2,
- RPC_LOC_QWIP_SUSPEND = 0 + 3,
- RPC_LOC_QWIP_REQUEST_MAX = 268435456,
-};
-typedef enum rpc_loc_qwip_request_e_type rpc_loc_qwip_request_e_type;
-
-struct rpc_loc_qwip_request_s_type {
- rpc_loc_qwip_request_e_type request_type;
- rpc_uint16 tbf_ms;
-};
-typedef struct rpc_loc_qwip_request_s_type rpc_loc_qwip_request_s_type;
-
-struct rpc_loc_reserved_payload_s_type {
- rpc_uint16 data_size;
- struct {
- u_int data_len;
- char *data_val;
- } data;
-};
-typedef struct rpc_loc_reserved_payload_s_type rpc_loc_reserved_payload_s_type;
-
-enum rpc_loc_ioctl_e_type {
- RPC_LOC_IOCTL_GET_API_VERSION = 1,
- RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
- RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
- RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
- RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
- RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
- RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
- RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
- RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
- RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
- RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
- RPC_LOC_IOCTL_INJECT_POSITION = 407,
- RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
- RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
- RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
- RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT = 411,
- RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS = 412,
- RPC_LOC_IOCTL_ACCESS_EFS_DATA = 413,
- RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG = 414,
- RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415,
- RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
- RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
- RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
- RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
- RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
- RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
- RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
- RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
- RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
- RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
- RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
- RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
- RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
- RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
- RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
- RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL = 814,
- RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815,
- RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816,
- RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817,
- RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818,
- RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819,
- RPC_LOC_IOCTL_SET_DATA_ENABLE = 820,
- RPC_LOC_IOCTL_SET_SUPL_VERSION = 821,
- RPC_LOC_IOCTL_GET_SUPL_VERSION = 822,
- RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
- RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
- RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
- RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
- RPC_LOC_IOCTL_RESERVED_CMD = 8000,
- RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824,
-};
-typedef enum rpc_loc_ioctl_e_type rpc_loc_ioctl_e_type;
-
-struct rpc_loc_api_version_s_type {
- u_char major;
- u_char minor;
-};
-typedef struct rpc_loc_api_version_s_type rpc_loc_api_version_s_type;
-
-enum rpc_loc_fix_recurrence_e_type {
- RPC_LOC_PERIODIC_FIX = 1,
- RPC_LOC_SINGLE_FIX = 2,
- RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456,
-};
-typedef enum rpc_loc_fix_recurrence_e_type rpc_loc_fix_recurrence_e_type;
-
-enum rpc_loc_operation_mode_e_type {
- RPC_LOC_OPER_MODE_DEFAULT = 1,
- RPC_LOC_OPER_MODE_MSB = 2,
- RPC_LOC_OPER_MODE_MSA = 3,
- RPC_LOC_OPER_MODE_STANDALONE = 4,
- RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
- RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
- RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
- RPC_LOC_OPER_MODE_CELL_ID = 8,
- RPC_LOC_OPER_MODE_MAX = 268435456,
-};
-typedef enum rpc_loc_operation_mode_e_type rpc_loc_operation_mode_e_type;
-
-enum rpc_loc_notify_e_type {
- RPC_LOC_NOTIFY_ON_INTERVAL = 1,
- RPC_LOC_NOTIFY_ON_DISTANCE = 2,
- RPC_LOC_NOTIFY_ON_ANY = 3,
- RPC_LOC_NOTIFY_ON_ALL = 4,
- RPC_LOC_NOTIFY_TYPE_MAX = 268435456,
-};
-typedef enum rpc_loc_notify_e_type rpc_loc_notify_e_type;
-
-struct rpc_loc_fix_criteria_s_type {
- rpc_uint32 valid_mask;
- rpc_loc_fix_recurrence_e_type recurrence_type;
- rpc_loc_operation_mode_e_type preferred_operation_mode;
- rpc_uint32 preferred_accuracy;
- rpc_uint32 preferred_response_time;
- rpc_boolean intermediate_pos_report_enabled;
- rpc_loc_notify_e_type notify_type;
- rpc_uint32 min_interval;
- float min_distance;
- rpc_uint32 min_dist_sample_interval;
-};
-typedef struct rpc_loc_fix_criteria_s_type rpc_loc_fix_criteria_s_type;
-
-enum rpc_loc_ni_user_resp_e_type {
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456,
-};
-typedef enum rpc_loc_ni_user_resp_e_type rpc_loc_ni_user_resp_e_type;
-
-struct rpc_loc_user_verify_s_type {
- rpc_loc_ni_user_resp_e_type user_resp;
- rpc_loc_ni_event_s_type ni_event_pass_back;
-};
-typedef struct rpc_loc_user_verify_s_type rpc_loc_user_verify_s_type;
-
-enum rpc_loc_predicted_orbits_data_format_e_type {
- RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
- RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456,
-};
-typedef enum rpc_loc_predicted_orbits_data_format_e_type rpc_loc_predicted_orbits_data_format_e_type;
-
-struct rpc_loc_predicted_orbits_data_s_type {
- rpc_loc_predicted_orbits_data_format_e_type format_type;
- rpc_uint32 total_size;
- rpc_uint8 total_parts;
- rpc_uint8 part;
- rpc_uint16 part_len;
- struct {
- u_int data_ptr_len;
- char *data_ptr_val;
- } data_ptr;
-};
-typedef struct rpc_loc_predicted_orbits_data_s_type rpc_loc_predicted_orbits_data_s_type;
-
-struct rpc_loc_predicted_orbits_data_validity_report_s_type {
- rpc_uint64 start_time_utc;
- rpc_uint16 valid_duration_hrs;
-};
-typedef struct rpc_loc_predicted_orbits_data_validity_report_s_type rpc_loc_predicted_orbits_data_validity_report_s_type;
-
-struct rpc_loc_predicted_orbits_auto_download_config_s_type {
- rpc_boolean enable;
- u_char auto_check_every_hrs;
-};
-typedef struct rpc_loc_predicted_orbits_auto_download_config_s_type rpc_loc_predicted_orbits_auto_download_config_s_type;
-
-struct rpc_loc_assist_data_time_s_type {
- rpc_uint64 time_utc;
- rpc_uint32 uncertainty;
-};
-typedef struct rpc_loc_assist_data_time_s_type rpc_loc_assist_data_time_s_type;
-
-typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
-
-struct rpc_loc_assist_data_pos_s_type {
- rpc_loc_assist_pos_valid_mask_type valid_mask;
- rpc_uint64 timestamp_utc;
- double latitude;
- double longitude;
- float altitude_wrt_ellipsoid;
- float altitude_wrt_mean_sea_level;
- float hor_unc_circular;
- float vert_unc;
- u_char confidence_horizontal;
- u_char confidence_vertical;
- rpc_int32 timestamp_age;
-};
-typedef struct rpc_loc_assist_data_pos_s_type rpc_loc_assist_data_pos_s_type;
-
-enum rpc_loc_server_open_status_e_type {
- RPC_LOC_SERVER_OPEN_SUCCESS = 1,
- RPC_LOC_SERVER_OPEN_FAIL = 2,
- RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456,
-};
-typedef enum rpc_loc_server_open_status_e_type rpc_loc_server_open_status_e_type;
-
-enum rpc_loc_server_pdp_type_e_type {
- RPC_LOC_SERVER_PDP_IP = 0,
- RPC_LOC_SERVER_PDP_PPP = 0 + 1,
- RPC_LOC_SERVER_PDP_IPV6 = 0 + 2,
- RPC_LOC_SERVER_PDP_IPV4V6 = 0 + 3,
- RPC_LOC_SERVER_PDP_MAX = 268435456,
-};
-typedef enum rpc_loc_server_pdp_type_e_type rpc_loc_server_pdp_type_e_type;
-
-struct rpc_loc_server_open_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_open_status_e_type open_status;
- char apn_name[100];
-};
-typedef struct rpc_loc_server_open_status_s_type rpc_loc_server_open_status_s_type;
-
-struct rpc_loc_server_multi_open_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_open_status_e_type open_status;
- rpc_loc_server_pdp_type_e_type pdp_type;
- char apn_name[100];
-};
-typedef struct rpc_loc_server_multi_open_status_s_type rpc_loc_server_multi_open_status_s_type;
-
-enum rpc_loc_server_close_status_e_type {
- RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
- RPC_LOC_SERVER_CLOSE_FAIL = 2,
- RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456,
-};
-typedef enum rpc_loc_server_close_status_e_type rpc_loc_server_close_status_e_type;
-
-struct rpc_loc_server_close_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_close_status_e_type close_status;
-};
-typedef struct rpc_loc_server_close_status_s_type rpc_loc_server_close_status_s_type;
-
-struct rpc_loc_wiper_fix_time_s_type {
- rpc_uint32 slow_clock_count;
-};
-typedef struct rpc_loc_wiper_fix_time_s_type rpc_loc_wiper_fix_time_s_type;
-
-struct rpc_loc_wiper_fix_pos_s_type {
- rpc_int32 lat;
- rpc_int32 lon;
- rpc_uint16 HEPE;
- rpc_uint8 num_of_aps_used;
- rpc_uint8 fix_error_code;
-};
-typedef struct rpc_loc_wiper_fix_pos_s_type rpc_loc_wiper_fix_pos_s_type;
-
-struct rpc_loc_wiper_ap_info_s_type {
- char mac_addr[6];
- rpc_int32 rssi;
- rpc_uint16 channel;
- rpc_uint8 ap_qualifier;
-};
-typedef struct rpc_loc_wiper_ap_info_s_type rpc_loc_wiper_ap_info_s_type;
-
-struct rpc_loc_wiper_ap_set_s_type {
- rpc_uint8 num_of_aps;
- rpc_loc_wiper_ap_info_s_type ap_info[50];
-};
-typedef struct rpc_loc_wiper_ap_set_s_type rpc_loc_wiper_ap_set_s_type;
-
-struct rpc_loc_wiper_position_report_s_type {
- rpc_uint8 wiper_valid_info_flag;
- rpc_loc_wiper_fix_time_s_type wiper_fix_time;
- rpc_loc_wiper_fix_pos_s_type wiper_fix_position;
- rpc_loc_wiper_ap_set_s_type wiper_ap_set;
-};
-typedef struct rpc_loc_wiper_position_report_s_type rpc_loc_wiper_position_report_s_type;
-
-enum rpc_loc_wiper_status_e_type {
- RPC_LOC_WIPER_STATUS_AVAILABLE = 1,
- RPC_LOC_WIPER_STATUS_UNAVAILABLE = 2,
- RPC_LOC_WIPER_STATUS_E_SIZE = 268435456,
-};
-typedef enum rpc_loc_wiper_status_e_type rpc_loc_wiper_status_e_type;
-
-enum rpc_loc_fs_operation_e_type {
- RPC_LOC_FS_CREATE_WRITE_FILE = 1,
- RPC_LOC_FS_APPEND_FILE = 2,
- RPC_LOC_FS_DELETE_FILE = 3,
- RPC_LOC_FS_READ_FILE = 4,
- RPC_LOC_FS_MAX = 268435456,
-};
-typedef enum rpc_loc_fs_operation_e_type rpc_loc_fs_operation_e_type;
-
-struct rpc_loc_efs_data_s_type {
- char filename[64];
- rpc_loc_fs_operation_e_type operation;
- rpc_uint32 total_size;
- struct {
- u_int data_ptr_len;
- char *data_ptr_val;
- } data_ptr;
- rpc_uint32 part_len;
- rpc_uint8 part;
- rpc_uint8 total_parts;
- rpc_uint32 reserved;
-};
-typedef struct rpc_loc_efs_data_s_type rpc_loc_efs_data_s_type;
-
-enum rpc_loc_error_estimate_config_e_type {
- RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1,
- RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2,
- RPC_LOC_ERROR_ESTIMATE_MAX = 268435456,
-};
-typedef enum rpc_loc_error_estimate_config_e_type rpc_loc_error_estimate_config_e_type;
-
-struct rpc_loc_apn_profiles_type {
- rpc_uint32 srv_system_type;
- rpc_uint32 pdp_type;
- rpc_uint32 reserved;
- char apn_name[100];
-};
-typedef struct rpc_loc_apn_profiles_type rpc_loc_apn_profiles_type;
-
-enum rpc_loc_lock_e_type {
- RPC_LOC_LOCK_NONE = 1,
- RPC_LOC_LOCK_MI = 2,
- RPC_LOC_LOCK_MT = 3,
- RPC_LOC_LOCK_ALL = 4,
- RPC_LOC_LOCK_MAX = 268435456,
-};
-typedef enum rpc_loc_lock_e_type rpc_loc_lock_e_type;
-
-typedef rpc_uint32 rpc_loc_nmea_sentence_type;
-
-typedef rpc_uint32 rpc_loc_assist_data_type;
-
-struct rpc_loc_assist_data_delete_s_type {
- rpc_loc_assist_data_type type;
- rpc_uint32 reserved[8];
-};
-typedef struct rpc_loc_assist_data_delete_s_type rpc_loc_assist_data_delete_s_type;
-
-struct rpc_loc_ioctl_data_u_type {
- rpc_loc_ioctl_e_type disc;
- union {
- rpc_loc_fix_criteria_s_type fix_criteria;
- rpc_loc_user_verify_s_type user_verify_resp;
- rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
- rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
- rpc_loc_assist_data_time_s_type assistance_data_time;
- rpc_loc_assist_data_pos_s_type assistance_data_position;
- rpc_loc_server_open_status_s_type conn_open_status;
- rpc_loc_server_close_status_s_type conn_close_status;
- rpc_loc_wiper_position_report_s_type wiper_pos;
- rpc_loc_wiper_status_e_type wiper_status;
- rpc_loc_lock_e_type engine_lock;
- rpc_boolean sbas_mode;
- rpc_loc_nmea_sentence_type nmea_types;
- rpc_boolean on_demand_lpm;
- rpc_loc_server_info_s_type server_addr;
- rpc_loc_assist_data_delete_s_type assist_data_delete;
- rpc_loc_efs_data_s_type efs_data;
- rpc_loc_error_estimate_config_e_type error_estimate_config;
- rpc_uint8 xtra_t_session_control;
- rpc_loc_apn_profiles_type apn_profiles[6];
- rpc_boolean data_enable;
- rpc_uint32 supl_version;
- rpc_loc_server_multi_open_status_s_type multi_conn_open_status;
- rpc_loc_reserved_payload_s_type reserved;
- } rpc_loc_ioctl_data_u_type_u;
-};
-typedef struct rpc_loc_ioctl_data_u_type rpc_loc_ioctl_data_u_type;
-
-struct rpc_loc_ioctl_callback_data_u_type {
- rpc_loc_ioctl_e_type disc;
- union {
- rpc_loc_api_version_s_type api_version;
- rpc_loc_fix_criteria_s_type fix_criteria;
- rpc_loc_lock_e_type engine_lock;
- rpc_boolean sbas_mode;
- rpc_loc_nmea_sentence_type nmea_types;
- rpc_boolean on_demand_lpm;
- rpc_loc_server_info_s_type server_addr;
- rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
- rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
- rpc_uint8 xtra_t_session_control;
- rpc_loc_apn_profiles_type apn_profiles[6];
- rpc_uint32 supl_version;
- } rpc_loc_ioctl_callback_data_u_type_u;
-};
-typedef struct rpc_loc_ioctl_callback_data_u_type rpc_loc_ioctl_callback_data_u_type;
-
-struct rpc_loc_ioctl_callback_s_type {
- rpc_loc_ioctl_e_type type;
- rpc_int32 status;
- rpc_loc_ioctl_callback_data_u_type data;
-};
-typedef struct rpc_loc_ioctl_callback_s_type rpc_loc_ioctl_callback_s_type;
-
-struct rpc_loc_event_payload_u_type {
- u_quad_t disc;
- union {
- rpc_loc_parsed_position_s_type parsed_location_report;
- rpc_loc_gnss_info_s_type gnss_report;
- rpc_loc_nmea_report_s_type nmea_report;
- rpc_loc_ni_event_s_type ni_request;
- rpc_loc_assist_data_request_s_type assist_data_request;
- rpc_loc_server_request_s_type loc_server_request;
- rpc_loc_ioctl_callback_s_type ioctl_report;
- rpc_loc_status_event_s_type status_report;
- rpc_loc_qwip_request_s_type qwip_request;
- rpc_loc_reserved_payload_s_type reserved;
- } rpc_loc_event_payload_u_type_u;
-};
-typedef struct rpc_loc_event_payload_u_type rpc_loc_event_payload_u_type;
-
-/* the xdr functions */
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern bool_t xdr_rpc_loc_client_handle_type (XDR *, rpc_loc_client_handle_type*);
-extern bool_t xdr_rpc_loc_event_mask_type (XDR *, rpc_loc_event_mask_type*);
-extern bool_t xdr_rpc_loc_position_valid_mask_type (XDR *, rpc_loc_position_valid_mask_type*);
-extern bool_t xdr_rpc_loc_pos_technology_mask_type (XDR *, rpc_loc_pos_technology_mask_type*);
-extern bool_t xdr_rpc_loc_session_status_e_type (XDR *, rpc_loc_session_status_e_type*);
-extern bool_t xdr_rpc_loc_calendar_time_s_type (XDR *, rpc_loc_calendar_time_s_type*);
-extern bool_t xdr_rpc_loc_parsed_position_s_type (XDR *, rpc_loc_parsed_position_s_type*);
-extern bool_t xdr_rpc_loc_sv_system_e_type (XDR *, rpc_loc_sv_system_e_type*);
-extern bool_t xdr_rpc_loc_sv_status_e_type (XDR *, rpc_loc_sv_status_e_type*);
-extern bool_t xdr_rpc_loc_sv_info_valid_mask_type (XDR *, rpc_loc_sv_info_valid_mask_type*);
-extern bool_t xdr_rpc_loc_sv_info_s_type (XDR *, rpc_loc_sv_info_s_type*);
-extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type (XDR *, rpc_loc_gnss_info_valid_mask_type*);
-extern bool_t xdr_rpc_loc_gnss_info_s_type (XDR *, rpc_loc_gnss_info_s_type*);
-extern bool_t xdr_rpc_loc_nmea_report_s_type (XDR *, rpc_loc_nmea_report_s_type*);
-extern bool_t xdr_rpc_loc_status_event_e_type (XDR *, rpc_loc_status_event_e_type*);
-extern bool_t xdr_rpc_loc_engine_state_e_type (XDR *, rpc_loc_engine_state_e_type*);
-extern bool_t xdr_rpc_loc_fix_session_state_e_type (XDR *, rpc_loc_fix_session_state_e_type*);
-extern bool_t xdr_rpc_loc_status_event_payload_u_type (XDR *, rpc_loc_status_event_payload_u_type*);
-extern bool_t xdr_rpc_loc_status_event_s_type (XDR *, rpc_loc_status_event_s_type*);
-extern bool_t xdr_rpc_loc_server_addr_e_type (XDR *, rpc_loc_server_addr_e_type*);
-extern bool_t xdr_rpc_loc_server_addr_ipv4_type (XDR *, rpc_loc_server_addr_ipv4_type*);
-extern bool_t xdr_rpc_loc_server_addr_url_type (XDR *, rpc_loc_server_addr_url_type*);
-extern bool_t xdr_rpc_loc_server_addr_ipv6_type (XDR *, rpc_loc_server_addr_ipv6_type*);
-extern bool_t xdr_rpc_loc_server_addr_u_type (XDR *, rpc_loc_server_addr_u_type*);
-extern bool_t xdr_rpc_loc_server_info_s_type (XDR *, rpc_loc_server_info_s_type*);
-extern bool_t xdr_rpc_loc_ni_notify_verify_e_type (XDR *, rpc_loc_ni_notify_verify_e_type*);
-extern bool_t xdr_rpc_loc_ni_event_e_type (XDR *, rpc_loc_ni_event_e_type*);
-extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *, rpc_loc_ni_datacoding_scheme_e_type*);
-extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type*);
-extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *, rpc_loc_ni_vx_pos_mode_e_type*);
-extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *, rpc_loc_ni_vx_requester_id_s_type*);
-extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *, rpc_loc_ni_vx_notify_verify_req_s_type*);
-extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *, rpc_loc_ni_supl_pos_method_e_type*);
-extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *, rpc_loc_ni_supl_slp_session_id_s_type*);
-extern bool_t xdr_rpc_loc_ni_requestor_id_s_type (XDR *, rpc_loc_ni_requestor_id_s_type*);
-extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type (XDR *, rpc_loc_ni_supl_client_name_s_type*);
-extern bool_t xdr_rpc_loc_ni_supl_qop_s_type (XDR *, rpc_loc_ni_supl_qop_s_type*);
-extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *, rpc_loc_ni_supl_notify_verify_req_s_type*);
-extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type (XDR *, rpc_loc_ni_ext_client_address_s_type*);
-extern bool_t xdr_rpc_loc_ni_location_type_e_type (XDR *, rpc_loc_ni_location_type_e_type*);
-extern bool_t xdr_rpc_loc_ni_deferred_location_s_type (XDR *, rpc_loc_ni_deferred_location_s_type*);
-extern bool_t xdr_rpc_loc_ni_codeword_string_s_type (XDR *, rpc_loc_ni_codeword_string_s_type*);
-extern bool_t xdr_rpc_loc_ni_service_type_id_s_type (XDR *, rpc_loc_ni_service_type_id_s_type*);
-extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *, rpc_loc_ni_umts_cp_notify_verify_req_s_type*);
-extern bool_t xdr_rpc_loc_ni_service_interaction_e_type (XDR *, rpc_loc_ni_service_interaction_e_type*);
-extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *, rpc_loc_ni_vx_service_interaction_req_s_type*);
-extern bool_t xdr_rpc_loc_ni_event_payload_u_type (XDR *, rpc_loc_ni_event_payload_u_type*);
-extern bool_t xdr_rpc_loc_ni_event_s_type (XDR *, rpc_loc_ni_event_s_type*);
-extern bool_t xdr_rpc_loc_assist_data_request_e_type (XDR *, rpc_loc_assist_data_request_e_type*);
-extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *, rpc_struct_loc_time_download_source_s_type_servers_ptr*);
-extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *, rpc_struct_loc_time_download_source_s_type_servers);
-extern bool_t xdr_rpc_loc_time_download_source_s_type (XDR *, rpc_loc_time_download_source_s_type*);
-extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr*);
-extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *, rpc_struct_loc_predicted_orbits_data_source_s_type_servers);
-extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *, rpc_loc_predicted_orbits_data_source_s_type*);
-extern bool_t xdr_rpc_loc_pos_inj_request_s_type (XDR *, rpc_loc_pos_inj_request_s_type*);
-extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type (XDR *, rpc_loc_assist_data_request_payload_u_type*);
-extern bool_t xdr_rpc_loc_assist_data_request_s_type (XDR *, rpc_loc_assist_data_request_s_type*);
-extern bool_t xdr_rpc_loc_server_connection_handle (XDR *, rpc_loc_server_connection_handle*);
-extern bool_t xdr_rpc_loc_server_protocol_e_type (XDR *, rpc_loc_server_protocol_e_type*);
-extern bool_t xdr_rpc_loc_server_connection_e_type (XDR *, rpc_loc_server_connection_e_type*);
-extern bool_t xdr_rpc_loc_server_request_e_type (XDR *, rpc_loc_server_request_e_type*);
-extern bool_t xdr_rpc_loc_server_open_req_s_type (XDR *, rpc_loc_server_open_req_s_type*);
-extern bool_t xdr_rpc_loc_server_multi_open_req_s_type (XDR *, rpc_loc_server_multi_open_req_s_type*);
-extern bool_t xdr_rpc_loc_server_close_req_s_type (XDR *, rpc_loc_server_close_req_s_type*);
-extern bool_t xdr_rpc_loc_server_request_u_type (XDR *, rpc_loc_server_request_u_type*);
-extern bool_t xdr_rpc_loc_server_request_s_type (XDR *, rpc_loc_server_request_s_type*);
-extern bool_t xdr_rpc_loc_qwip_request_e_type (XDR *, rpc_loc_qwip_request_e_type*);
-extern bool_t xdr_rpc_loc_qwip_request_s_type (XDR *, rpc_loc_qwip_request_s_type*);
-extern bool_t xdr_rpc_loc_reserved_payload_s_type (XDR *, rpc_loc_reserved_payload_s_type*);
-extern bool_t xdr_rpc_loc_ioctl_e_type (XDR *, rpc_loc_ioctl_e_type*);
-extern bool_t xdr_rpc_loc_api_version_s_type (XDR *, rpc_loc_api_version_s_type*);
-extern bool_t xdr_rpc_loc_fix_recurrence_e_type (XDR *, rpc_loc_fix_recurrence_e_type*);
-extern bool_t xdr_rpc_loc_operation_mode_e_type (XDR *, rpc_loc_operation_mode_e_type*);
-extern bool_t xdr_rpc_loc_notify_e_type (XDR *, rpc_loc_notify_e_type*);
-extern bool_t xdr_rpc_loc_fix_criteria_s_type (XDR *, rpc_loc_fix_criteria_s_type*);
-extern bool_t xdr_rpc_loc_ni_user_resp_e_type (XDR *, rpc_loc_ni_user_resp_e_type*);
-extern bool_t xdr_rpc_loc_user_verify_s_type (XDR *, rpc_loc_user_verify_s_type*);
-extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *, rpc_loc_predicted_orbits_data_format_e_type*);
-extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type (XDR *, rpc_loc_predicted_orbits_data_s_type*);
-extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *, rpc_loc_predicted_orbits_data_validity_report_s_type*);
-extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *, rpc_loc_predicted_orbits_auto_download_config_s_type*);
-extern bool_t xdr_rpc_loc_assist_data_time_s_type (XDR *, rpc_loc_assist_data_time_s_type*);
-extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type (XDR *, rpc_loc_assist_pos_valid_mask_type*);
-extern bool_t xdr_rpc_loc_assist_data_pos_s_type (XDR *, rpc_loc_assist_data_pos_s_type*);
-extern bool_t xdr_rpc_loc_server_open_status_e_type (XDR *, rpc_loc_server_open_status_e_type*);
-extern bool_t xdr_rpc_loc_server_pdp_type_e_type (XDR *, rpc_loc_server_pdp_type_e_type*);
-extern bool_t xdr_rpc_loc_server_open_status_s_type (XDR *, rpc_loc_server_open_status_s_type*);
-extern bool_t xdr_rpc_loc_server_multi_open_status_s_type (XDR *, rpc_loc_server_multi_open_status_s_type*);
-extern bool_t xdr_rpc_loc_server_close_status_e_type (XDR *, rpc_loc_server_close_status_e_type*);
-extern bool_t xdr_rpc_loc_server_close_status_s_type (XDR *, rpc_loc_server_close_status_s_type*);
-extern bool_t xdr_rpc_loc_wiper_fix_time_s_type (XDR *, rpc_loc_wiper_fix_time_s_type*);
-extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type (XDR *, rpc_loc_wiper_fix_pos_s_type*);
-extern bool_t xdr_rpc_loc_wiper_ap_info_s_type (XDR *, rpc_loc_wiper_ap_info_s_type*);
-extern bool_t xdr_rpc_loc_wiper_ap_set_s_type (XDR *, rpc_loc_wiper_ap_set_s_type*);
-extern bool_t xdr_rpc_loc_wiper_position_report_s_type (XDR *, rpc_loc_wiper_position_report_s_type*);
-extern bool_t xdr_rpc_loc_wiper_status_e_type (XDR *, rpc_loc_wiper_status_e_type*);
-extern bool_t xdr_rpc_loc_fs_operation_e_type (XDR *, rpc_loc_fs_operation_e_type*);
-extern bool_t xdr_rpc_loc_efs_data_s_type (XDR *, rpc_loc_efs_data_s_type*);
-extern bool_t xdr_rpc_loc_error_estimate_config_e_type (XDR *, rpc_loc_error_estimate_config_e_type*);
-extern bool_t xdr_rpc_loc_apn_profiles_type (XDR *, rpc_loc_apn_profiles_type*);
-extern bool_t xdr_rpc_loc_lock_e_type (XDR *, rpc_loc_lock_e_type*);
-extern bool_t xdr_rpc_loc_nmea_sentence_type (XDR *, rpc_loc_nmea_sentence_type*);
-extern bool_t xdr_rpc_loc_assist_data_type (XDR *, rpc_loc_assist_data_type*);
-extern bool_t xdr_rpc_loc_assist_data_delete_s_type (XDR *, rpc_loc_assist_data_delete_s_type*);
-extern bool_t xdr_rpc_loc_ioctl_data_u_type (XDR *, rpc_loc_ioctl_data_u_type*);
-extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type (XDR *, rpc_loc_ioctl_callback_data_u_type*);
-extern bool_t xdr_rpc_loc_ioctl_callback_s_type (XDR *, rpc_loc_ioctl_callback_s_type*);
-extern bool_t xdr_rpc_loc_event_payload_u_type (XDR *, rpc_loc_event_payload_u_type*);
-
-#else /* K&R C */
-extern bool_t xdr_rpc_loc_client_handle_type ();
-extern bool_t xdr_rpc_loc_event_mask_type ();
-extern bool_t xdr_rpc_loc_position_valid_mask_type ();
-extern bool_t xdr_rpc_loc_pos_technology_mask_type ();
-extern bool_t xdr_rpc_loc_session_status_e_type ();
-extern bool_t xdr_rpc_loc_calendar_time_s_type ();
-extern bool_t xdr_rpc_loc_parsed_position_s_type ();
-extern bool_t xdr_rpc_loc_sv_system_e_type ();
-extern bool_t xdr_rpc_loc_sv_status_e_type ();
-extern bool_t xdr_rpc_loc_sv_info_valid_mask_type ();
-extern bool_t xdr_rpc_loc_sv_info_s_type ();
-extern bool_t xdr_rpc_loc_gnss_info_valid_mask_type ();
-extern bool_t xdr_rpc_loc_gnss_info_s_type ();
-extern bool_t xdr_rpc_loc_nmea_report_s_type ();
-extern bool_t xdr_rpc_loc_status_event_e_type ();
-extern bool_t xdr_rpc_loc_engine_state_e_type ();
-extern bool_t xdr_rpc_loc_fix_session_state_e_type ();
-extern bool_t xdr_rpc_loc_status_event_payload_u_type ();
-extern bool_t xdr_rpc_loc_status_event_s_type ();
-extern bool_t xdr_rpc_loc_server_addr_e_type ();
-extern bool_t xdr_rpc_loc_server_addr_ipv4_type ();
-extern bool_t xdr_rpc_loc_server_addr_url_type ();
-extern bool_t xdr_rpc_loc_server_addr_ipv6_type ();
-extern bool_t xdr_rpc_loc_server_addr_u_type ();
-extern bool_t xdr_rpc_loc_server_info_s_type ();
-extern bool_t xdr_rpc_loc_ni_notify_verify_e_type ();
-extern bool_t xdr_rpc_loc_ni_event_e_type ();
-extern bool_t xdr_rpc_loc_ni_datacoding_scheme_e_type ();
-extern bool_t xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type ();
-extern bool_t xdr_rpc_loc_ni_vx_pos_mode_e_type ();
-extern bool_t xdr_rpc_loc_ni_vx_requester_id_s_type ();
-extern bool_t xdr_rpc_loc_ni_vx_notify_verify_req_s_type ();
-extern bool_t xdr_rpc_loc_ni_supl_pos_method_e_type ();
-extern bool_t xdr_rpc_loc_ni_supl_slp_session_id_s_type ();
-extern bool_t xdr_rpc_loc_ni_requestor_id_s_type ();
-extern bool_t xdr_rpc_loc_ni_supl_client_name_s_type ();
-extern bool_t xdr_rpc_loc_ni_supl_qop_s_type ();
-extern bool_t xdr_rpc_loc_ni_supl_notify_verify_req_s_type ();
-extern bool_t xdr_rpc_loc_ni_ext_client_address_s_type ();
-extern bool_t xdr_rpc_loc_ni_location_type_e_type ();
-extern bool_t xdr_rpc_loc_ni_deferred_location_s_type ();
-extern bool_t xdr_rpc_loc_ni_codeword_string_s_type ();
-extern bool_t xdr_rpc_loc_ni_service_type_id_s_type ();
-extern bool_t xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type ();
-extern bool_t xdr_rpc_loc_ni_service_interaction_e_type ();
-extern bool_t xdr_rpc_loc_ni_vx_service_interaction_req_s_type ();
-extern bool_t xdr_rpc_loc_ni_event_payload_u_type ();
-extern bool_t xdr_rpc_loc_ni_event_s_type ();
-extern bool_t xdr_rpc_loc_assist_data_request_e_type ();
-extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr ();
-extern bool_t xdr_rpc_struct_loc_time_download_source_s_type_servers ();
-extern bool_t xdr_rpc_loc_time_download_source_s_type ();
-extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr ();
-extern bool_t xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers ();
-extern bool_t xdr_rpc_loc_predicted_orbits_data_source_s_type ();
-extern bool_t xdr_rpc_loc_pos_inj_request_s_type ();
-extern bool_t xdr_rpc_loc_assist_data_request_payload_u_type ();
-extern bool_t xdr_rpc_loc_assist_data_request_s_type ();
-extern bool_t xdr_rpc_loc_server_connection_handle ();
-extern bool_t xdr_rpc_loc_server_protocol_e_type ();
-extern bool_t xdr_rpc_loc_server_connection_e_type ();
-extern bool_t xdr_rpc_loc_server_request_e_type ();
-extern bool_t xdr_rpc_loc_server_open_req_s_type ();
-extern bool_t xdr_rpc_loc_server_multi_open_req_s_type ();
-extern bool_t xdr_rpc_loc_server_close_req_s_type ();
-extern bool_t xdr_rpc_loc_server_request_u_type ();
-extern bool_t xdr_rpc_loc_server_request_s_type ();
-extern bool_t xdr_rpc_loc_qwip_request_e_type ();
-extern bool_t xdr_rpc_loc_qwip_request_s_type ();
-extern bool_t xdr_rpc_loc_reserved_payload_s_type ();
-extern bool_t xdr_rpc_loc_ioctl_e_type ();
-extern bool_t xdr_rpc_loc_api_version_s_type ();
-extern bool_t xdr_rpc_loc_fix_recurrence_e_type ();
-extern bool_t xdr_rpc_loc_operation_mode_e_type ();
-extern bool_t xdr_rpc_loc_notify_e_type ();
-extern bool_t xdr_rpc_loc_fix_criteria_s_type ();
-extern bool_t xdr_rpc_loc_ni_user_resp_e_type ();
-extern bool_t xdr_rpc_loc_user_verify_s_type ();
-extern bool_t xdr_rpc_loc_predicted_orbits_data_format_e_type ();
-extern bool_t xdr_rpc_loc_predicted_orbits_data_s_type ();
-extern bool_t xdr_rpc_loc_predicted_orbits_data_validity_report_s_type ();
-extern bool_t xdr_rpc_loc_predicted_orbits_auto_download_config_s_type ();
-extern bool_t xdr_rpc_loc_assist_data_time_s_type ();
-extern bool_t xdr_rpc_loc_assist_pos_valid_mask_type ();
-extern bool_t xdr_rpc_loc_assist_data_pos_s_type ();
-extern bool_t xdr_rpc_loc_server_open_status_e_type ();
-extern bool_t xdr_rpc_loc_server_pdp_type_e_type ();
-extern bool_t xdr_rpc_loc_server_open_status_s_type ();
-extern bool_t xdr_rpc_loc_server_multi_open_status_s_type ();
-extern bool_t xdr_rpc_loc_server_close_status_e_type ();
-extern bool_t xdr_rpc_loc_server_close_status_s_type ();
-extern bool_t xdr_rpc_loc_wiper_fix_time_s_type ();
-extern bool_t xdr_rpc_loc_wiper_fix_pos_s_type ();
-extern bool_t xdr_rpc_loc_wiper_ap_info_s_type ();
-extern bool_t xdr_rpc_loc_wiper_ap_set_s_type ();
-extern bool_t xdr_rpc_loc_wiper_position_report_s_type ();
-extern bool_t xdr_rpc_loc_wiper_status_e_type ();
-extern bool_t xdr_rpc_loc_fs_operation_e_type ();
-extern bool_t xdr_rpc_loc_efs_data_s_type ();
-extern bool_t xdr_rpc_loc_error_estimate_config_e_type ();
-extern bool_t xdr_rpc_loc_apn_profiles_type ();
-extern bool_t xdr_rpc_loc_lock_e_type ();
-extern bool_t xdr_rpc_loc_nmea_sentence_type ();
-extern bool_t xdr_rpc_loc_assist_data_type ();
-extern bool_t xdr_rpc_loc_assist_data_delete_s_type ();
-extern bool_t xdr_rpc_loc_ioctl_data_u_type ();
-extern bool_t xdr_rpc_loc_ioctl_callback_data_u_type ();
-extern bool_t xdr_rpc_loc_ioctl_callback_s_type ();
-extern bool_t xdr_rpc_loc_event_payload_u_type ();
-
-#endif /* K&R C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !_LOC_API_COMMON_RPC_H_RPCGEN */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h
deleted file mode 100644
index 6138432..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_api_rpcgen_rpc.h
+++ /dev/null
@@ -1,288 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#ifndef _LOC_API_RPC_H_RPCGEN
-#define _LOC_API_RPC_H_RPCGEN
-
-#include "librpc.h"
-#include "commondefs_rpcgen_rpc.h"
-#include "loc_api_rpcgen_common_rpc.h"
-
-#include <pthread.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-typedef struct {
- u_int rpc_loc_api_api_versions_return_type_len;
- rpc_uint32 *rpc_loc_api_api_versions_return_type_val;
-} rpc_loc_api_api_versions_return_type;
-
-typedef rpc_uint32 rpc_loc_event_cb_f_type;
-
-struct rpc_loc_open_args {
- rpc_loc_event_mask_type event_reg_mask;
- rpc_loc_event_cb_f_type event_callback;
-};
-typedef struct rpc_loc_open_args rpc_loc_open_args;
-
-struct rpc_loc_close_args {
- rpc_loc_client_handle_type handle;
-};
-typedef struct rpc_loc_close_args rpc_loc_close_args;
-
-struct rpc_loc_start_fix_args {
- rpc_loc_client_handle_type handle;
-};
-typedef struct rpc_loc_start_fix_args rpc_loc_start_fix_args;
-
-struct rpc_loc_stop_fix_args {
- rpc_loc_client_handle_type handle;
-};
-typedef struct rpc_loc_stop_fix_args rpc_loc_stop_fix_args;
-
-struct rpc_loc_ioctl_args {
- rpc_loc_client_handle_type handle;
- rpc_loc_ioctl_e_type ioctl_type;
- rpc_loc_ioctl_data_u_type *ioctl_data;
-};
-typedef struct rpc_loc_ioctl_args rpc_loc_ioctl_args;
-
-struct rpc_loc_api_api_version_s_args {
- rpc_boolean len_not_null;
-};
-typedef struct rpc_loc_api_api_version_s_args rpc_loc_api_api_version_s_args;
-
-struct rpc_loc_api_rpc_glue_code_info_remote_rets {
- rpc_uint32 toolvers;
- rpc_uint32 features;
- rpc_uint32 proghash;
- rpc_uint32 cbproghash;
-};
-typedef struct rpc_loc_api_rpc_glue_code_info_remote_rets rpc_loc_api_rpc_glue_code_info_remote_rets;
-
-struct rpc_loc_open_rets {
- rpc_loc_client_handle_type loc_open_result;
-};
-typedef struct rpc_loc_open_rets rpc_loc_open_rets;
-
-struct rpc_loc_close_rets {
- rpc_int32 loc_close_result;
-};
-typedef struct rpc_loc_close_rets rpc_loc_close_rets;
-
-struct rpc_loc_start_fix_rets {
- rpc_int32 loc_start_fix_result;
-};
-typedef struct rpc_loc_start_fix_rets rpc_loc_start_fix_rets;
-
-struct rpc_loc_stop_fix_rets {
- rpc_int32 loc_stop_fix_result;
-};
-typedef struct rpc_loc_stop_fix_rets rpc_loc_stop_fix_rets;
-
-struct rpc_loc_ioctl_rets {
- rpc_int32 loc_ioctl_result;
-};
-typedef struct rpc_loc_ioctl_rets rpc_loc_ioctl_rets;
-
-struct rpc_loc_api_api_versions_rets {
- rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
- rpc_uint32 *len;
-};
-typedef struct rpc_loc_api_api_versions_rets rpc_loc_api_api_versions_rets;
-#define LOC_APIVERS 0x00050006
-
-#define LOC_APIPROG 0x3000008C
-#define LOC_APIVERS_0001 0x00050001
-
-#if defined(__STDC__) || defined(__cplusplus)
-#define rpc_loc_api_null 0
-extern enum clnt_stat rpc_loc_api_null_0x00050001(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050001_svc(void *, void *, struct svc_req *);
-#define rpc_loc_api_rpc_glue_code_info_remote 1
-extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, CLIENT *);
-extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc(void *, rpc_loc_api_rpc_glue_code_info_remote_rets *, struct svc_req *);
-#define rpc_loc_open 2
-extern enum clnt_stat rpc_loc_open_0x00050001(rpc_loc_open_args *, rpc_loc_open_rets *, CLIENT *);
-extern bool_t rpc_loc_open_0x00050001_svc(rpc_loc_open_args *, rpc_loc_open_rets *, struct svc_req *);
-#define rpc_loc_close 3
-extern enum clnt_stat rpc_loc_close_0x00050001(rpc_loc_close_args *, rpc_loc_close_rets *, CLIENT *);
-extern bool_t rpc_loc_close_0x00050001_svc(rpc_loc_close_args *, rpc_loc_close_rets *, struct svc_req *);
-#define rpc_loc_start_fix 4
-extern enum clnt_stat rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, CLIENT *);
-extern bool_t rpc_loc_start_fix_0x00050001_svc(rpc_loc_start_fix_args *, rpc_loc_start_fix_rets *, struct svc_req *);
-#define rpc_loc_stop_fix 5
-extern enum clnt_stat rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, CLIENT *);
-extern bool_t rpc_loc_stop_fix_0x00050001_svc(rpc_loc_stop_fix_args *, rpc_loc_stop_fix_rets *, struct svc_req *);
-#define rpc_loc_ioctl 6
-extern enum clnt_stat rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, CLIENT *);
-extern bool_t rpc_loc_ioctl_0x00050001_svc(rpc_loc_ioctl_args *, rpc_loc_ioctl_rets *, struct svc_req *);
-#define rpc_loc_api_api_versions 0xFFFFFFFF
-extern enum clnt_stat rpc_loc_api_api_versions_0x00050001(void *, rpc_loc_api_api_versions_rets *, CLIENT *);
-extern bool_t rpc_loc_api_api_versions_0x00050001_svc(void *, rpc_loc_api_api_versions_rets *, struct svc_req *);
-extern int loc_apiprog_0x00050001_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-#define rpc_loc_api_null 0
-extern enum clnt_stat rpc_loc_api_null_0x00050001();
-extern bool_t rpc_loc_api_null_0x00050001_svc();
-#define rpc_loc_api_rpc_glue_code_info_remote 1
-extern enum clnt_stat rpc_loc_api_rpc_glue_code_info_remote_0x00050001();
-extern bool_t rpc_loc_api_rpc_glue_code_info_remote_0x00050001_svc();
-#define rpc_loc_open 2
-extern enum clnt_stat rpc_loc_open_0x00050001();
-extern bool_t rpc_loc_open_0x00050001_svc();
-#define rpc_loc_close 3
-extern enum clnt_stat rpc_loc_close_0x00050001();
-extern bool_t rpc_loc_close_0x00050001_svc();
-#define rpc_loc_start_fix 4
-extern enum clnt_stat rpc_loc_start_fix_0x00050001();
-extern bool_t rpc_loc_start_fix_0x00050001_svc();
-#define rpc_loc_stop_fix 5
-extern enum clnt_stat rpc_loc_stop_fix_0x00050001();
-extern bool_t rpc_loc_stop_fix_0x00050001_svc();
-#define rpc_loc_ioctl 6
-extern enum clnt_stat rpc_loc_ioctl_0x00050001();
-extern bool_t rpc_loc_ioctl_0x00050001_svc();
-#define rpc_loc_api_api_versions 0xFFFFFFFF
-extern enum clnt_stat rpc_loc_api_api_versions_0x00050001();
-extern bool_t rpc_loc_api_api_versions_0x00050001_svc();
-extern int loc_apiprog_0x00050001_freeresult ();
-#endif /* K&R C */
-#define LOC_APIVERS_0002 0x00050002
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_null_0x00050002(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050002_svc(void *, void *, struct svc_req *);
-extern int loc_apiprog_0x00050002_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_null_0x00050002();
-extern bool_t rpc_loc_api_null_0x00050002_svc();
-extern int loc_apiprog_0x00050002_freeresult ();
-#endif /* K&R C */
-#define LOC_APIVERS_0003 0x00050003
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_null_0x00050003(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050003_svc(void *, void *, struct svc_req *);
-extern int loc_apiprog_0x00050003_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_null_0x00050003();
-extern bool_t rpc_loc_api_null_0x00050003_svc();
-extern int loc_apiprog_0x00050003_freeresult ();
-#endif /* K&R C */
-#define LOC_APIVERS_0004 0x00050004
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_null_0x00050004(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050004_svc(void *, void *, struct svc_req *);
-extern int loc_apiprog_0x00050004_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_null_0x00050004();
-extern bool_t rpc_loc_api_null_0x00050004_svc();
-extern int loc_apiprog_0x00050004_freeresult ();
-#endif /* K&R C */
-#define LOC_APIVERS_0005 0x00050005
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_null_0x00050005(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050005_svc(void *, void *, struct svc_req *);
-extern int loc_apiprog_0x00050005_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_null_0x00050005();
-extern bool_t rpc_loc_api_null_0x00050005_svc();
-extern int loc_apiprog_0x00050005_freeresult ();
-#endif /* K&R C */
-#define LOC_APIVERS_0006 0x00050006
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern enum clnt_stat rpc_loc_api_null_0x00050006(void *, void *, CLIENT *);
-extern bool_t rpc_loc_api_null_0x00050006_svc(void *, void *, struct svc_req *);
-extern int loc_apiprog_0x00050006_freeresult (SVCXPRT *, xdrproc_t, caddr_t);
-
-#else /* K&R C */
-extern enum clnt_stat rpc_loc_api_null_0x00050006();
-extern bool_t rpc_loc_api_null_0x00050006_svc();
-extern int loc_apiprog_0x00050006_freeresult ();
-#endif /* K&R C */
-
-/* the xdr functions */
-
-#if defined(__STDC__) || defined(__cplusplus)
-extern bool_t xdr_rpc_loc_api_api_versions_return_type (XDR *, rpc_loc_api_api_versions_return_type*);
-extern bool_t xdr_rpc_loc_event_cb_f_type (XDR *, rpc_loc_event_cb_f_type*);
-extern bool_t xdr_rpc_loc_open_args (XDR *, rpc_loc_open_args*);
-extern bool_t xdr_rpc_loc_close_args (XDR *, rpc_loc_close_args*);
-extern bool_t xdr_rpc_loc_start_fix_args (XDR *, rpc_loc_start_fix_args*);
-extern bool_t xdr_rpc_loc_stop_fix_args (XDR *, rpc_loc_stop_fix_args*);
-extern bool_t xdr_rpc_loc_ioctl_args (XDR *, rpc_loc_ioctl_args*);
-extern bool_t xdr_rpc_loc_api_api_version_s_args (XDR *, rpc_loc_api_api_version_s_args*);
-extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *, rpc_loc_api_rpc_glue_code_info_remote_rets*);
-extern bool_t xdr_rpc_loc_open_rets (XDR *, rpc_loc_open_rets*);
-extern bool_t xdr_rpc_loc_close_rets (XDR *, rpc_loc_close_rets*);
-extern bool_t xdr_rpc_loc_start_fix_rets (XDR *, rpc_loc_start_fix_rets*);
-extern bool_t xdr_rpc_loc_stop_fix_rets (XDR *, rpc_loc_stop_fix_rets*);
-extern bool_t xdr_rpc_loc_ioctl_rets (XDR *, rpc_loc_ioctl_rets*);
-extern bool_t xdr_rpc_loc_api_api_versions_rets (XDR *, rpc_loc_api_api_versions_rets*);
-
-#else /* K&R C */
-extern bool_t xdr_rpc_loc_api_api_versions_return_type ();
-extern bool_t xdr_rpc_loc_event_cb_f_type ();
-extern bool_t xdr_rpc_loc_open_args ();
-extern bool_t xdr_rpc_loc_close_args ();
-extern bool_t xdr_rpc_loc_start_fix_args ();
-extern bool_t xdr_rpc_loc_stop_fix_args ();
-extern bool_t xdr_rpc_loc_ioctl_args ();
-extern bool_t xdr_rpc_loc_api_api_version_s_args ();
-extern bool_t xdr_rpc_loc_api_rpc_glue_code_info_remote_rets ();
-extern bool_t xdr_rpc_loc_open_rets ();
-extern bool_t xdr_rpc_loc_close_rets ();
-extern bool_t xdr_rpc_loc_start_fix_rets ();
-extern bool_t xdr_rpc_loc_stop_fix_rets ();
-extern bool_t xdr_rpc_loc_ioctl_rets ();
-extern bool_t xdr_rpc_loc_api_api_versions_rets ();
-
-#endif /* K&R C */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !_LOC_API_RPC_H_RPCGEN */
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h
deleted file mode 100644
index 875c4f0..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/inc/loc_apicb_appinit.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-/* Initialization function for callbacks */
-int loc_apicb_app_init();
-
-void loc_apicb_app_deinit();
-
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c
deleted file mode 100644
index 2ef5852..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_svc.c
+++ /dev/null
@@ -1,327 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include "loc_api_rpcgen_cb_rpc.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <rpc/pmap_clnt.h>
-#include <string.h>
-#include <memory.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-
-#ifndef SIG_PF
-#define SIG_PF void(*)(int)
-#endif
-
-void
-loc_apicbprog_0x00050001(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- rpc_loc_event_cb_f_type_args rpc_loc_event_cb_f_type_0x00050001_arg;
- } argument;
- union {
- rpc_loc_event_cb_f_type_rets rpc_loc_event_cb_f_type_0x00050001_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_event_cb_f_type:
- _xdr_argument = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_args;
- _xdr_result = (xdrproc_t) xdr_rpc_loc_event_cb_f_type_rets;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_event_cb_f_type_0x00050001_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050001_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
-
-void
-loc_apicbprog_0x00050002(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- int fill;
- } argument;
- union {
- int rpc_loc_api_cb_null_0x00050002_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_api_cb_null:
- _xdr_argument = (xdrproc_t) xdr_void;
- _xdr_result = (xdrproc_t) xdr_int;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050002_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050002_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
-
-void
-loc_apicbprog_0x00050003(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- int fill;
- } argument;
- union {
- int rpc_loc_api_cb_null_0x00050003_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_api_cb_null:
- _xdr_argument = (xdrproc_t) xdr_void;
- _xdr_result = (xdrproc_t) xdr_int;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050003_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050003_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
-
-void
-loc_apicbprog_0x00050004(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- int fill;
- } argument;
- union {
- int rpc_loc_api_cb_null_0x00050004_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_api_cb_null:
- _xdr_argument = (xdrproc_t) xdr_void;
- _xdr_result = (xdrproc_t) xdr_int;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050004_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050004_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
-
-void
-loc_apicbprog_0x00050005(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- int fill;
- } argument;
- union {
- int rpc_loc_api_cb_null_0x00050005_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_api_cb_null:
- _xdr_argument = (xdrproc_t) xdr_void;
- _xdr_result = (xdrproc_t) xdr_int;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050005_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050005_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
-
-void
-loc_apicbprog_0x00050006(struct svc_req *rqstp, register SVCXPRT *transp)
-{
- union {
- int fill;
- } argument;
- union {
- int rpc_loc_api_cb_null_0x00050006_res;
- } result;
- bool_t retval;
- xdrproc_t _xdr_argument, _xdr_result;
- bool_t (*local)(char *, void *, struct svc_req *);
-
- switch (rqstp->rq_proc) {
- case NULLPROC:
- (void) svc_sendreply (transp, (xdrproc_t) xdr_void, (char *)NULL);
- return;
-
- case rpc_loc_api_cb_null:
- _xdr_argument = (xdrproc_t) xdr_void;
- _xdr_result = (xdrproc_t) xdr_int;
- local = (bool_t (*) (char *, void *, struct svc_req *))rpc_loc_api_cb_null_0x00050006_svc;
- break;
-
- default:
- svcerr_noproc (transp);
- return;
- }
- memset ((char *)&argument, 0, sizeof (argument));
- if (!svc_getargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- svcerr_decode (transp);
- return;
- }
- retval = (bool_t) (*local)((char *)&argument, (void *)&result, rqstp);
- if (retval > 0 && !svc_sendreply(transp, (xdrproc_t) _xdr_result, (char *)&result)) {
- svcerr_systemerr (transp);
- }
- if (!svc_freeargs (transp, (xdrproc_t) _xdr_argument, (caddr_t) &argument)) {
- fprintf (stderr, "%s", "unable to free arguments");
- exit (1);
- }
- if (!loc_apicbprog_0x00050006_freeresult (transp, _xdr_result, (caddr_t) &result))
- fprintf (stderr, "%s", "unable to free results");
-
- return;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c
deleted file mode 100644
index ad171dc..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_cb_xdr.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include "loc_api_rpcgen_cb_rpc.h"
-
-bool_t
-xdr_rpc_loc_event_cb_f_type_args (XDR *xdrs, rpc_loc_event_cb_f_type_args *objp)
-{
-;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->cb_id))
- return FALSE;
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_handle))
- return FALSE;
- if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->loc_event))
- return FALSE;
- if (!xdr_pointer (xdrs, (char **)&objp->loc_event_payload, sizeof (rpc_loc_event_payload_u_type), (xdrproc_t) xdr_rpc_loc_event_payload_u_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_event_cb_f_type_rets (XDR *xdrs, rpc_loc_event_cb_f_type_rets *objp)
-{
-;
-
- if (!xdr_rpc_int32 (xdrs, &objp->loc_event_cb_f_type_result))
- return FALSE;
- return TRUE;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c
deleted file mode 100644
index 3e39576..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_clnt.c
+++ /dev/null
@@ -1,155 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include <memory.h> /* for memset */
-#include "loc_api_rpcgen_rpc.h"
-
-/* Default timeout can be changed using clnt_control() */
-static struct timeval TIMEOUT = { 25, 0 };
-
-enum clnt_stat
-rpc_loc_api_null_0x00050001(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_rpc_glue_code_info_remote_0x00050001(void *argp, rpc_loc_api_rpc_glue_code_info_remote_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_rpc_glue_code_info_remote,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_api_rpc_glue_code_info_remote_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_open_0x00050001(rpc_loc_open_args *argp, rpc_loc_open_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_open,
- (xdrproc_t) xdr_rpc_loc_open_args, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_open_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_close_0x00050001(rpc_loc_close_args *argp, rpc_loc_close_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_close,
- (xdrproc_t) xdr_rpc_loc_close_args, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_close_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_start_fix_0x00050001(rpc_loc_start_fix_args *argp, rpc_loc_start_fix_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_start_fix,
- (xdrproc_t) xdr_rpc_loc_start_fix_args, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_start_fix_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_stop_fix_0x00050001(rpc_loc_stop_fix_args *argp, rpc_loc_stop_fix_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_stop_fix,
- (xdrproc_t) xdr_rpc_loc_stop_fix_args, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_stop_fix_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_ioctl_0x00050001(rpc_loc_ioctl_args *argp, rpc_loc_ioctl_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_ioctl,
- (xdrproc_t) xdr_rpc_loc_ioctl_args, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_ioctl_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_api_versions_0x00050001(void *argp, rpc_loc_api_api_versions_rets *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_api_versions,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_rpc_loc_api_api_versions_rets, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_null_0x00050002(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_null_0x00050003(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_null_0x00050004(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_null_0x00050005(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
-
-enum clnt_stat
-rpc_loc_api_null_0x00050006(void *argp, void *clnt_res, CLIENT *clnt)
-{
- return (clnt_call(clnt, rpc_loc_api_null,
- (xdrproc_t) xdr_void, (caddr_t) argp,
- (xdrproc_t) xdr_void, (caddr_t) clnt_res,
- TIMEOUT));
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c
deleted file mode 100644
index 21be8f4..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_common_xdr.c
+++ /dev/null
@@ -1,1775 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include "loc_api_rpcgen_common_rpc.h"
-
-bool_t
-xdr_rpc_loc_client_handle_type (XDR *xdrs, rpc_loc_client_handle_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_int32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_event_mask_type (XDR *xdrs, rpc_loc_event_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint64 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_position_valid_mask_type (XDR *xdrs, rpc_loc_position_valid_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint64 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_pos_technology_mask_type (XDR *xdrs, rpc_loc_pos_technology_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_session_status_e_type (XDR *xdrs, rpc_loc_session_status_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_calendar_time_s_type (XDR *xdrs, rpc_loc_calendar_time_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint16 (xdrs, &objp->year))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->month))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->day_of_week))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->day))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->hour))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->minute))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->second))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->millisecond))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_parsed_position_s_type (XDR *xdrs, rpc_loc_parsed_position_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_position_valid_mask_type (xdrs, &objp->valid_mask))
- return FALSE;
- if (!xdr_rpc_loc_session_status_e_type (xdrs, &objp->session_status))
- return FALSE;
- if (!xdr_rpc_loc_calendar_time_s_type (xdrs, &objp->timestamp_calendar))
- return FALSE;
- if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->leap_seconds))
- return FALSE;
- if (!xdr_float (xdrs, &objp->time_unc))
- return FALSE;
- if (!xdr_double (xdrs, &objp->latitude))
- return FALSE;
- if (!xdr_double (xdrs, &objp->longitude))
- return FALSE;
- if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid))
- return FALSE;
- if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level))
- return FALSE;
- if (!xdr_float (xdrs, &objp->speed_horizontal))
- return FALSE;
- if (!xdr_float (xdrs, &objp->speed_vertical))
- return FALSE;
- if (!xdr_float (xdrs, &objp->heading))
- return FALSE;
- if (!xdr_float (xdrs, &objp->hor_unc_circular))
- return FALSE;
- if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_major))
- return FALSE;
- if (!xdr_float (xdrs, &objp->hor_unc_ellipse_semi_minor))
- return FALSE;
- if (!xdr_float (xdrs, &objp->hor_unc_ellipse_orient_azimuth))
- return FALSE;
- if (!xdr_float (xdrs, &objp->vert_unc))
- return FALSE;
- if (!xdr_float (xdrs, &objp->speed_unc))
- return FALSE;
- if (!xdr_float (xdrs, &objp->heading_unc))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->confidence_horizontal))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->confidence_vertical))
- return FALSE;
- if (!xdr_float (xdrs, &objp->magnetic_deviation))
- return FALSE;
- if (!xdr_rpc_loc_pos_technology_mask_type (xdrs, &objp->technology_mask))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_sv_system_e_type (XDR *xdrs, rpc_loc_sv_system_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_sv_status_e_type (XDR *xdrs, rpc_loc_sv_status_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_sv_info_valid_mask_type (XDR *xdrs, rpc_loc_sv_info_valid_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_sv_info_s_type (XDR *xdrs, rpc_loc_sv_info_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_sv_info_valid_mask_type (xdrs, &objp->valid_mask))
- return FALSE;
- if (!xdr_rpc_loc_sv_system_e_type (xdrs, &objp->system))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->prn))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->health_status))
- return FALSE;
- if (!xdr_rpc_loc_sv_status_e_type (xdrs, &objp->process_status))
- return FALSE;
- if (!xdr_rpc_boolean (xdrs, &objp->has_eph))
- return FALSE;
- if (!xdr_rpc_boolean (xdrs, &objp->has_alm))
- return FALSE;
- if (!xdr_float (xdrs, &objp->elevation))
- return FALSE;
- if (!xdr_float (xdrs, &objp->azimuth))
- return FALSE;
- if (!xdr_float (xdrs, &objp->snr))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_gnss_info_valid_mask_type (XDR *xdrs, rpc_loc_gnss_info_valid_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_gnss_info_s_type (XDR *xdrs, rpc_loc_gnss_info_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_gnss_info_valid_mask_type (xdrs, &objp->valid_mask))
- return FALSE;
- if (!xdr_float (xdrs, &objp->position_dop))
- return FALSE;
- if (!xdr_float (xdrs, &objp->horizontal_dop))
- return FALSE;
- if (!xdr_float (xdrs, &objp->vertical_dop))
- return FALSE;
- if (!xdr_rpc_boolean (xdrs, &objp->altitude_assumed))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->sv_count))
- return FALSE;
- if (!xdr_array (xdrs, (char **)&objp->sv_list.sv_list_val, (u_int *) &objp->sv_list.sv_list_len, 80,
- sizeof (rpc_loc_sv_info_s_type), (xdrproc_t) xdr_rpc_loc_sv_info_s_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_nmea_report_s_type (XDR *xdrs, rpc_loc_nmea_report_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_uint16 (xdrs, &objp->length))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->nmea_sentences, 200))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_status_event_e_type (XDR *xdrs, rpc_loc_status_event_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_engine_state_e_type (XDR *xdrs, rpc_loc_engine_state_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_fix_session_state_e_type (XDR *xdrs, rpc_loc_fix_session_state_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_status_event_payload_u_type (XDR *xdrs, rpc_loc_status_event_payload_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
- if (!xdr_rpc_loc_engine_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.engine_state))
- return FALSE;
- break;
- case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
- if (!xdr_rpc_loc_fix_session_state_e_type (xdrs, &objp->rpc_loc_status_event_payload_u_type_u.fix_session_state))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_status_event_s_type (XDR *xdrs, rpc_loc_status_event_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_status_event_e_type (xdrs, &objp->event))
- return FALSE;
- if (!xdr_rpc_loc_status_event_payload_u_type (xdrs, &objp->payload))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_addr_e_type (XDR *xdrs, rpc_loc_server_addr_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_addr_ipv4_type (XDR *xdrs, rpc_loc_server_addr_ipv4_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->addr))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->port))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_addr_url_type (XDR *xdrs, rpc_loc_server_addr_url_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_uint16 (xdrs, &objp->length))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->addr, 256))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_addr_ipv6_type (XDR *xdrs, rpc_loc_server_addr_ipv6_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_vector (xdrs, (char *)objp->addr, 8,
- sizeof (rpc_uint16), (xdrproc_t) xdr_rpc_uint16))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->port))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_addr_u_type (XDR *xdrs, rpc_loc_server_addr_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_SERVER_ADDR_IPV4:
- if (!xdr_rpc_loc_server_addr_ipv4_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv4))
- return FALSE;
- break;
- case RPC_LOC_SERVER_ADDR_URL:
- if (!xdr_rpc_loc_server_addr_url_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.url))
- return FALSE;
- break;
- case RPC_LOC_SERVER_ADDR_IPV6:
- if (!xdr_rpc_loc_server_addr_ipv6_type (xdrs, &objp->rpc_loc_server_addr_u_type_u.ipv6))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_info_s_type (XDR *xdrs, rpc_loc_server_info_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_addr_e_type (xdrs, &objp->addr_type))
- return FALSE;
- if (!xdr_rpc_loc_server_addr_u_type (xdrs, &objp->addr_info))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_notify_verify_e_type (XDR *xdrs, rpc_loc_ni_notify_verify_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_event_e_type (XDR *xdrs, rpc_loc_ni_event_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_datacoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_datacoding_scheme_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_encoding_scheme_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_vx_pos_mode_e_type (XDR *xdrs, rpc_loc_ni_vx_pos_mode_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_vx_requester_id_s_type (XDR *xdrs, rpc_loc_ni_vx_requester_id_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->requester_id_length))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->requester_id, 200))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_vx_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_vx_notify_verify_req_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->pos_qos_incl))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->pos_qos))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->num_fixes))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->tbf))
- return FALSE;
- if (!xdr_rpc_loc_ni_vx_pos_mode_e_type (xdrs, &objp->pos_mode))
- return FALSE;
- if (!xdr_rpc_loc_ni_vx_requester_id_encoding_scheme_e_type (xdrs, &objp->encoding_scheme))
- return FALSE;
- if (!xdr_rpc_loc_ni_vx_requester_id_s_type (xdrs, &objp->requester_id))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->user_resp_timer_val))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_supl_pos_method_e_type (XDR *xdrs, rpc_loc_ni_supl_pos_method_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_supl_slp_session_id_s_type (XDR *xdrs, rpc_loc_ni_supl_slp_session_id_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->presence))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->session_id, 4))
- return FALSE;
- if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->slp_address))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_requestor_id_s_type (XDR *xdrs, rpc_loc_ni_requestor_id_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->requestor_id_string, 200))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->string_len))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_supl_client_name_s_type (XDR *xdrs, rpc_loc_ni_supl_client_name_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->client_name_string, 64))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->string_len))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_supl_qop_s_type (XDR *xdrs, rpc_loc_ni_supl_qop_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_u_char (xdrs, &objp->bit_mask))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->horacc))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->veracc))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->maxLocAge))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->delay))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_supl_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_supl_notify_verify_req_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_rpc_loc_ni_supl_slp_session_id_s_type (xdrs, &objp->supl_slp_session_id))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->supl_hash, 8))
- return FALSE;
- if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme))
- return FALSE;
- if (!xdr_rpc_loc_ni_supl_pos_method_e_type (xdrs, &objp->pos_method))
- return FALSE;
- if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id))
- return FALSE;
- if (!xdr_rpc_loc_ni_supl_client_name_s_type (xdrs, &objp->client_name))
- return FALSE;
- if (!xdr_rpc_loc_ni_supl_qop_s_type (xdrs, &objp->supl_qop))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_ext_client_address_s_type (XDR *xdrs, rpc_loc_ni_ext_client_address_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->ext_client_address_len))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->ext_client_address, 20))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_location_type_e_type (XDR *xdrs, rpc_loc_ni_location_type_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_deferred_location_s_type (XDR *xdrs, rpc_loc_ni_deferred_location_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_u_char (xdrs, &objp->unused_bits))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->ms_available))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_codeword_string_s_type (XDR *xdrs, rpc_loc_ni_codeword_string_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_u_char (xdrs, &objp->data_coding_scheme))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->lcs_codeword_string, 20))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->string_len))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_service_type_id_s_type (XDR *xdrs, rpc_loc_ni_service_type_id_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_u_char (xdrs, &objp->lcs_service_type_id))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (XDR *xdrs, rpc_loc_ni_umts_cp_notify_verify_req_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_loc_ni_notify_verify_e_type (xdrs, &objp->notification_priv_type))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->invoke_id))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->notification_length))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->notification_text, 64))
- return FALSE;
- if (!xdr_rpc_loc_ni_datacoding_scheme_e_type (xdrs, &objp->datacoding_scheme))
- return FALSE;
- if (!xdr_rpc_loc_ni_ext_client_address_s_type (xdrs, &objp->ext_client_address_data))
- return FALSE;
- if (!xdr_rpc_loc_ni_location_type_e_type (xdrs, &objp->location_type))
- return FALSE;
- if (!xdr_rpc_loc_ni_deferred_location_s_type (xdrs, &objp->deferred_location))
- return FALSE;
- if (!xdr_rpc_loc_ni_requestor_id_s_type (xdrs, &objp->requestor_id))
- return FALSE;
- if (!xdr_rpc_loc_ni_codeword_string_s_type (xdrs, &objp->codeword_string))
- return FALSE;
- if (!xdr_rpc_loc_ni_service_type_id_s_type (xdrs, &objp->service_type_id))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->user_response_timer))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_service_interaction_e_type (XDR *xdrs, rpc_loc_ni_service_interaction_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_vx_service_interaction_req_s_type (XDR *xdrs, rpc_loc_ni_vx_service_interaction_req_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->ni_vx_req))
- return FALSE;
- if (!xdr_rpc_loc_ni_service_interaction_e_type (xdrs, &objp->service_interation_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_event_payload_u_type (XDR *xdrs, rpc_loc_ni_event_payload_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
- if (!xdr_rpc_loc_ni_vx_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.vx_req))
- return FALSE;
- break;
- case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
- if (!xdr_rpc_loc_ni_supl_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.supl_req))
- return FALSE;
- break;
- case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
- if (!xdr_rpc_loc_ni_umts_cp_notify_verify_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.umts_cp_req))
- return FALSE;
- break;
- case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ:
- if (!xdr_rpc_loc_ni_vx_service_interaction_req_s_type (xdrs, &objp->rpc_loc_ni_event_payload_u_type_u.service_interaction_req))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_event_s_type (XDR *xdrs, rpc_loc_ni_event_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ni_event_e_type (xdrs, &objp->event))
- return FALSE;
- if (!xdr_rpc_loc_ni_event_payload_u_type (xdrs, &objp->payload))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_request_e_type (XDR *xdrs, rpc_loc_assist_data_request_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers_ptr *objp)
-{
- register int32_t *buf;
-
- if (!xdr_string (xdrs, objp, 256))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_struct_loc_time_download_source_s_type_servers (XDR *xdrs, rpc_struct_loc_time_download_source_s_type_servers objp)
-{
- register int32_t *buf;
-
- if (!xdr_vector (xdrs, (char *)objp, 3,
- sizeof (rpc_struct_loc_time_download_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_time_download_source_s_type_servers_ptr))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_time_download_source_s_type (XDR *xdrs, rpc_loc_time_download_source_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->delay_threshold))
- return FALSE;
- if (!xdr_rpc_struct_loc_time_download_source_s_type_servers (xdrs, objp->servers))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr *objp)
-{
- register int32_t *buf;
-
- if (!xdr_string (xdrs, objp, 256))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (XDR *xdrs, rpc_struct_loc_predicted_orbits_data_source_s_type_servers objp)
-{
- register int32_t *buf;
-
- if (!xdr_vector (xdrs, (char *)objp, 3,
- sizeof (rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr), (xdrproc_t) xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_predicted_orbits_data_source_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_source_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->max_file_size))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->max_part_size))
- return FALSE;
- if (!xdr_rpc_struct_loc_predicted_orbits_data_source_s_type_servers (xdrs, objp->servers))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_pos_inj_request_s_type (XDR *xdrs, rpc_loc_pos_inj_request_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->flags))
- return FALSE;
- if (!xdr_double (xdrs, &objp->latitude))
- return FALSE;
- if (!xdr_double (xdrs, &objp->longitude))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->position_uncertainty))
- return FALSE;
- if (!xdr_rpc_uint64 (xdrs, &objp->timestamp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_request_payload_u_type (XDR *xdrs, rpc_loc_assist_data_request_payload_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_ASSIST_DATA_TIME_REQ:
- if (!xdr_rpc_loc_time_download_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.time_download))
- return FALSE;
- break;
- case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
- if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.data_download))
- return FALSE;
- break;
- case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ:
- if (!xdr_rpc_loc_pos_inj_request_s_type (xdrs, &objp->rpc_loc_assist_data_request_payload_u_type_u.pos_injection))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_request_s_type (XDR *xdrs, rpc_loc_assist_data_request_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_assist_data_request_e_type (xdrs, &objp->event))
- return FALSE;
- if (!xdr_rpc_loc_assist_data_request_payload_u_type (xdrs, &objp->payload))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_connection_handle (XDR *xdrs, rpc_loc_server_connection_handle *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_protocol_e_type (XDR *xdrs, rpc_loc_server_protocol_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_connection_e_type (XDR *xdrs, rpc_loc_server_connection_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_request_e_type (XDR *xdrs, rpc_loc_server_request_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_open_req_s_type (XDR *xdrs, rpc_loc_server_open_req_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_multi_open_req_s_type (XDR *xdrs, rpc_loc_server_multi_open_req_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- if (!xdr_rpc_loc_server_protocol_e_type (xdrs, &objp->protocol))
- return FALSE;
- if (!xdr_rpc_loc_server_connection_e_type (xdrs, &objp->connection_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_close_req_s_type (XDR *xdrs, rpc_loc_server_close_req_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_request_u_type (XDR *xdrs, rpc_loc_server_request_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_SERVER_REQUEST_OPEN:
- if (!xdr_rpc_loc_server_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.open_req))
- return FALSE;
- break;
- case RPC_LOC_SERVER_REQUEST_CLOSE:
- if (!xdr_rpc_loc_server_close_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.close_req))
- return FALSE;
- break;
- case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
- if (!xdr_rpc_loc_server_multi_open_req_s_type (xdrs, &objp->rpc_loc_server_request_u_type_u.multi_open_req))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_request_s_type (XDR *xdrs, rpc_loc_server_request_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_request_e_type (xdrs, &objp->event))
- return FALSE;
- if (!xdr_rpc_loc_server_request_u_type (xdrs, &objp->payload))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_qwip_request_e_type (XDR *xdrs, rpc_loc_qwip_request_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_qwip_request_s_type (XDR *xdrs, rpc_loc_qwip_request_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_qwip_request_e_type (xdrs, &objp->request_type))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->tbf_ms))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_reserved_payload_s_type (XDR *xdrs, rpc_loc_reserved_payload_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint16 (xdrs, &objp->data_size))
- return FALSE;
- if (!xdr_bytes (xdrs, (char **)&objp->data.data_val, (u_int *) &objp->data.data_len, ~0))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_e_type (XDR *xdrs, rpc_loc_ioctl_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_api_version_s_type (XDR *xdrs, rpc_loc_api_version_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_u_char (xdrs, &objp->major))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->minor))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_fix_recurrence_e_type (XDR *xdrs, rpc_loc_fix_recurrence_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_operation_mode_e_type (XDR *xdrs, rpc_loc_operation_mode_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_notify_e_type (XDR *xdrs, rpc_loc_notify_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_fix_criteria_s_type (XDR *xdrs, rpc_loc_fix_criteria_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->valid_mask))
- return FALSE;
- if (!xdr_rpc_loc_fix_recurrence_e_type (xdrs, &objp->recurrence_type))
- return FALSE;
- if (!xdr_rpc_loc_operation_mode_e_type (xdrs, &objp->preferred_operation_mode))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->preferred_accuracy))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->preferred_response_time))
- return FALSE;
- if (!xdr_rpc_boolean (xdrs, &objp->intermediate_pos_report_enabled))
- return FALSE;
- if (!xdr_rpc_loc_notify_e_type (xdrs, &objp->notify_type))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->min_interval))
- return FALSE;
- if (!xdr_float (xdrs, &objp->min_distance))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->min_dist_sample_interval))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ni_user_resp_e_type (XDR *xdrs, rpc_loc_ni_user_resp_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_user_verify_s_type (XDR *xdrs, rpc_loc_user_verify_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ni_user_resp_e_type (xdrs, &objp->user_resp))
- return FALSE;
- if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->ni_event_pass_back))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_predicted_orbits_data_format_e_type (XDR *xdrs, rpc_loc_predicted_orbits_data_format_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_predicted_orbits_data_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_predicted_orbits_data_format_e_type (xdrs, &objp->format_type))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->total_size))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->total_parts))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->part))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->part_len))
- return FALSE;
- if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (XDR *xdrs, rpc_loc_predicted_orbits_data_validity_report_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint64 (xdrs, &objp->start_time_utc))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->valid_duration_hrs))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (XDR *xdrs, rpc_loc_predicted_orbits_auto_download_config_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_boolean (xdrs, &objp->enable))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->auto_check_every_hrs))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_time_s_type (XDR *xdrs, rpc_loc_assist_data_time_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint64 (xdrs, &objp->time_utc))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->uncertainty))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_pos_valid_mask_type (XDR *xdrs, rpc_loc_assist_pos_valid_mask_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint64 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_pos_s_type (XDR *xdrs, rpc_loc_assist_data_pos_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_assist_pos_valid_mask_type (xdrs, &objp->valid_mask))
- return FALSE;
- if (!xdr_rpc_uint64 (xdrs, &objp->timestamp_utc))
- return FALSE;
- if (!xdr_double (xdrs, &objp->latitude))
- return FALSE;
- if (!xdr_double (xdrs, &objp->longitude))
- return FALSE;
- if (!xdr_float (xdrs, &objp->altitude_wrt_ellipsoid))
- return FALSE;
- if (!xdr_float (xdrs, &objp->altitude_wrt_mean_sea_level))
- return FALSE;
- if (!xdr_float (xdrs, &objp->hor_unc_circular))
- return FALSE;
- if (!xdr_float (xdrs, &objp->vert_unc))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->confidence_horizontal))
- return FALSE;
- if (!xdr_u_char (xdrs, &objp->confidence_vertical))
- return FALSE;
- if (!xdr_rpc_int32 (xdrs, &objp->timestamp_age))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_open_status_e_type (XDR *xdrs, rpc_loc_server_open_status_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_pdp_type_e_type (XDR *xdrs, rpc_loc_server_pdp_type_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_open_status_s_type (XDR *xdrs, rpc_loc_server_open_status_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->apn_name, 100))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_multi_open_status_s_type (XDR *xdrs, rpc_loc_server_multi_open_status_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- if (!xdr_rpc_loc_server_open_status_e_type (xdrs, &objp->open_status))
- return FALSE;
- if (!xdr_rpc_loc_server_pdp_type_e_type (xdrs, &objp->pdp_type))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->apn_name, 100))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_close_status_e_type (XDR *xdrs, rpc_loc_server_close_status_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_server_close_status_s_type (XDR *xdrs, rpc_loc_server_close_status_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_server_connection_handle (xdrs, &objp->conn_handle))
- return FALSE;
- if (!xdr_rpc_loc_server_close_status_e_type (xdrs, &objp->close_status))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_fix_time_s_type (XDR *xdrs, rpc_loc_wiper_fix_time_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->slow_clock_count))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_fix_pos_s_type (XDR *xdrs, rpc_loc_wiper_fix_pos_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_int32 (xdrs, &objp->lat))
- return FALSE;
- if (!xdr_rpc_int32 (xdrs, &objp->lon))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->HEPE))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps_used))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->fix_error_code))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_ap_info_s_type (XDR *xdrs, rpc_loc_wiper_ap_info_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_opaque (xdrs, objp->mac_addr, 6))
- return FALSE;
- if (!xdr_rpc_int32 (xdrs, &objp->rssi))
- return FALSE;
- if (!xdr_rpc_uint16 (xdrs, &objp->channel))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->ap_qualifier))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_ap_set_s_type (XDR *xdrs, rpc_loc_wiper_ap_set_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_uint8 (xdrs, &objp->num_of_aps))
- return FALSE;
- if (!xdr_vector (xdrs, (char *)objp->ap_info, 50,
- sizeof (rpc_loc_wiper_ap_info_s_type), (xdrproc_t) xdr_rpc_loc_wiper_ap_info_s_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_position_report_s_type (XDR *xdrs, rpc_loc_wiper_position_report_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint8 (xdrs, &objp->wiper_valid_info_flag))
- return FALSE;
- if (!xdr_rpc_loc_wiper_fix_time_s_type (xdrs, &objp->wiper_fix_time))
- return FALSE;
- if (!xdr_rpc_loc_wiper_fix_pos_s_type (xdrs, &objp->wiper_fix_position))
- return FALSE;
- if (!xdr_rpc_loc_wiper_ap_set_s_type (xdrs, &objp->wiper_ap_set))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_wiper_status_e_type (XDR *xdrs, rpc_loc_wiper_status_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_fs_operation_e_type (XDR *xdrs, rpc_loc_fs_operation_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_efs_data_s_type (XDR *xdrs, rpc_loc_efs_data_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_opaque (xdrs, objp->filename, 64))
- return FALSE;
- if (!xdr_rpc_loc_fs_operation_e_type (xdrs, &objp->operation))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->total_size))
- return FALSE;
- if (!xdr_bytes (xdrs, (char **)&objp->data_ptr.data_ptr_val, (u_int *) &objp->data_ptr.data_ptr_len, ~0))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->part_len))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->part))
- return FALSE;
- if (!xdr_rpc_uint8 (xdrs, &objp->total_parts))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->reserved))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_error_estimate_config_e_type (XDR *xdrs, rpc_loc_error_estimate_config_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_apn_profiles_type (XDR *xdrs, rpc_loc_apn_profiles_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_uint32 (xdrs, &objp->srv_system_type))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->pdp_type))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->reserved))
- return FALSE;
- if (!xdr_opaque (xdrs, objp->apn_name, 100))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_lock_e_type (XDR *xdrs, rpc_loc_lock_e_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_enum (xdrs, (enum_t *) objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_nmea_sentence_type (XDR *xdrs, rpc_loc_nmea_sentence_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_type (XDR *xdrs, rpc_loc_assist_data_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_assist_data_delete_s_type (XDR *xdrs, rpc_loc_assist_data_delete_s_type *objp)
-{
- register int32_t *buf;
-
- int i;
- if (!xdr_rpc_loc_assist_data_type (xdrs, &objp->type))
- return FALSE;
- if (!xdr_vector (xdrs, (char *)objp->reserved, 8,
- sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_data_u_type (XDR *xdrs, rpc_loc_ioctl_data_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
- if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.fix_criteria))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
- if (!xdr_rpc_loc_user_verify_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.user_verify_resp))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
- if (!xdr_rpc_loc_predicted_orbits_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_data))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
- if (!xdr_rpc_loc_predicted_orbits_auto_download_config_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.predicted_orbits_auto_download))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INJECT_UTC_TIME:
- if (!xdr_rpc_loc_assist_data_time_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_time))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INJECT_POSITION:
- if (!xdr_rpc_loc_assist_data_pos_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assistance_data_position))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
- if (!xdr_rpc_loc_server_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_open_status))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
- if (!xdr_rpc_loc_server_close_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.conn_close_status))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT:
- if (!xdr_rpc_loc_wiper_position_report_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_pos))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS:
- if (!xdr_rpc_loc_wiper_status_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.wiper_status))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
- if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.engine_lock))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
- if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.sbas_mode))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_NMEA_TYPES:
- if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.nmea_types))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
- if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.on_demand_lpm))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
- if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.server_addr))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
- if (!xdr_rpc_loc_assist_data_delete_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.assist_data_delete))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_ACCESS_EFS_DATA:
- if (!xdr_rpc_loc_efs_data_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.efs_data))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG:
- if (!xdr_rpc_loc_error_estimate_config_e_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.error_estimate_config))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL:
- if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.xtra_t_session_control))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE:
- case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE:
- if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_data_u_type_u.apn_profiles, 6,
- sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_DATA_ENABLE:
- if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.data_enable))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_SET_SUPL_VERSION:
- if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.supl_version))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS:
- if (!xdr_rpc_loc_server_multi_open_status_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.multi_conn_open_status))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_RESERVED_CMD:
- if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_ioctl_data_u_type_u.reserved))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_callback_data_u_type (XDR *xdrs, rpc_loc_ioctl_callback_data_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_IOCTL_GET_API_VERSION:
- if (!xdr_rpc_loc_api_version_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.api_version))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
- if (!xdr_rpc_loc_fix_criteria_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.fix_criteria))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
- if (!xdr_rpc_loc_lock_e_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.engine_lock))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
- if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.sbas_mode))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_NMEA_TYPES:
- if (!xdr_rpc_loc_nmea_sentence_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.nmea_types))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
- if (!xdr_rpc_boolean (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.on_demand_lpm))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
- if (!xdr_rpc_loc_server_info_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.server_addr))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
- if (!xdr_rpc_loc_predicted_orbits_data_source_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_source))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
- if (!xdr_rpc_loc_predicted_orbits_data_validity_report_s_type (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.predicted_orbits_data_validity))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL:
- if (!xdr_rpc_uint8 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.xtra_t_session_control))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE:
- case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE:
- if (!xdr_vector (xdrs, (char *)objp->rpc_loc_ioctl_callback_data_u_type_u.apn_profiles, 6,
- sizeof (rpc_loc_apn_profiles_type), (xdrproc_t) xdr_rpc_loc_apn_profiles_type))
- return FALSE;
- break;
- case RPC_LOC_IOCTL_GET_SUPL_VERSION:
- if (!xdr_rpc_uint32 (xdrs, &objp->rpc_loc_ioctl_callback_data_u_type_u.supl_version))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_callback_s_type (XDR *xdrs, rpc_loc_ioctl_callback_s_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->type))
- return FALSE;
- if (!xdr_rpc_int32 (xdrs, &objp->status))
- return FALSE;
- if (!xdr_rpc_loc_ioctl_callback_data_u_type (xdrs, &objp->data))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_event_payload_u_type (XDR *xdrs, rpc_loc_event_payload_u_type *objp)
-{
- register int32_t *buf;
-
- if (!xdr_u_quad_t (xdrs, &objp->disc))
- return FALSE;
- switch (objp->disc) {
- case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
- if (!xdr_rpc_loc_parsed_position_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.parsed_location_report))
- return FALSE;
- break;
- case RPC_LOC_EVENT_SATELLITE_REPORT:
- if (!xdr_rpc_loc_gnss_info_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.gnss_report))
- return FALSE;
- break;
- case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
- case RPC_LOC_EVENT_NMEA_1HZ_REPORT:
- if (!xdr_rpc_loc_nmea_report_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.nmea_report))
- return FALSE;
- break;
- case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
- if (!xdr_rpc_loc_ni_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ni_request))
- return FALSE;
- break;
- case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
- if (!xdr_rpc_loc_assist_data_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.assist_data_request))
- return FALSE;
- break;
- case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
- if (!xdr_rpc_loc_server_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.loc_server_request))
- return FALSE;
- break;
- case RPC_LOC_EVENT_IOCTL_REPORT:
- if (!xdr_rpc_loc_ioctl_callback_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.ioctl_report))
- return FALSE;
- break;
- case RPC_LOC_EVENT_STATUS_REPORT:
- if (!xdr_rpc_loc_status_event_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.status_report))
- return FALSE;
- break;
- case RPC_LOC_EVENT_WPS_NEEDED_REQUEST:
- if (!xdr_rpc_loc_qwip_request_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.qwip_request))
- return FALSE;
- break;
- case RPC_LOC_EVENT_RESERVED:
- if (!xdr_rpc_loc_reserved_payload_s_type (xdrs, &objp->rpc_loc_event_payload_u_type_u.reserved))
- return FALSE;
- break;
- default:
- break;
- }
- return TRUE;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c
deleted file mode 100644
index a0fdcab..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_api_rpcgen_xdr.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
- * Please do not edit this file.
- * It was generated using rpcgen.
- */
-
-#include "loc_api_rpcgen_rpc.h"
-
-bool_t
-xdr_rpc_loc_api_api_versions_return_type (XDR *xdrs, rpc_loc_api_api_versions_return_type *objp)
-{
-;
-
- if (!xdr_array (xdrs, (char **)&objp->rpc_loc_api_api_versions_return_type_val, (u_int *) &objp->rpc_loc_api_api_versions_return_type_len, ~0,
- sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_event_cb_f_type (XDR *xdrs, rpc_loc_event_cb_f_type *objp)
-{
-;
-
- if (!xdr_rpc_uint32 (xdrs, objp))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_open_args (XDR *xdrs, rpc_loc_open_args *objp)
-{
-;
-
- if (!xdr_rpc_loc_event_mask_type (xdrs, &objp->event_reg_mask))
- return FALSE;
- if (!xdr_rpc_loc_event_cb_f_type (xdrs, &objp->event_callback))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_close_args (XDR *xdrs, rpc_loc_close_args *objp)
-{
-;
-
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_start_fix_args (XDR *xdrs, rpc_loc_start_fix_args *objp)
-{
-;
-
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_stop_fix_args (XDR *xdrs, rpc_loc_stop_fix_args *objp)
-{
-;
-
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_args (XDR *xdrs, rpc_loc_ioctl_args *objp)
-{
-;
-
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->handle))
- return FALSE;
- if (!xdr_rpc_loc_ioctl_e_type (xdrs, &objp->ioctl_type))
- return FALSE;
- if (!xdr_pointer (xdrs, (char **)&objp->ioctl_data, sizeof (rpc_loc_ioctl_data_u_type), (xdrproc_t) xdr_rpc_loc_ioctl_data_u_type))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_api_api_version_s_args (XDR *xdrs, rpc_loc_api_api_version_s_args *objp)
-{
-;
-
- if (!xdr_rpc_boolean (xdrs, &objp->len_not_null))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_api_rpc_glue_code_info_remote_rets (XDR *xdrs, rpc_loc_api_rpc_glue_code_info_remote_rets *objp)
-{
-;
-
- if (!xdr_rpc_uint32 (xdrs, &objp->toolvers))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->features))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->proghash))
- return FALSE;
- if (!xdr_rpc_uint32 (xdrs, &objp->cbproghash))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_open_rets (XDR *xdrs, rpc_loc_open_rets *objp)
-{
-;
-
- if (!xdr_rpc_loc_client_handle_type (xdrs, &objp->loc_open_result))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_close_rets (XDR *xdrs, rpc_loc_close_rets *objp)
-{
-;
-
- if (!xdr_rpc_int32 (xdrs, &objp->loc_close_result))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_start_fix_rets (XDR *xdrs, rpc_loc_start_fix_rets *objp)
-{
-;
-
- if (!xdr_rpc_int32 (xdrs, &objp->loc_start_fix_result))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_stop_fix_rets (XDR *xdrs, rpc_loc_stop_fix_rets *objp)
-{
-;
-
- if (!xdr_rpc_int32 (xdrs, &objp->loc_stop_fix_result))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_ioctl_rets (XDR *xdrs, rpc_loc_ioctl_rets *objp)
-{
-;
-
- if (!xdr_rpc_int32 (xdrs, &objp->loc_ioctl_result))
- return FALSE;
- return TRUE;
-}
-
-bool_t
-xdr_rpc_loc_api_api_versions_rets (XDR *xdrs, rpc_loc_api_api_versions_rets *objp)
-{
-;
-
- if (!xdr_rpc_loc_api_api_versions_return_type (xdrs, &objp->loc_api_api_versions_result))
- return FALSE;
- if (!xdr_pointer (xdrs, (char **)&objp->len, sizeof (rpc_uint32), (xdrproc_t) xdr_rpc_uint32))
- return FALSE;
- return TRUE;
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c
deleted file mode 100644
index b469eb0..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/src/loc_apicb_appinit.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include "librpc.h"
-#include "loc_api_rpcgen_rpc.h"
-#include "loc_api_rpcgen_cb_rpc.h"
-
-
-#define RPC_FUNC_VERSION_BASE(a,b) a ## b
-#define RPC_CB_FUNC_VERS(a,b) RPC_FUNC_VERSION_BASE(a,b)
-
-
-static SVCXPRT* svrPort = NULL;
-
-extern void RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001)(struct svc_req *rqstp, register SVCXPRT *transp);
-
-int loc_apicb_app_init(void)
-{
-
- /* Register a callback server to use the loc_apicbprog_0x00010001 */
- if (svrPort == NULL) {
- svrPort = svcrtr_create();
- }
- if (!svrPort) return -1;
-
- xprt_register(svrPort);
-
-
-
- if(svc_register(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001, RPC_CB_FUNC_VERS(loc_apicbprog_,LOC_APICBVERS_0001),0))
- {
- return 0;
- }
- else
- {
- return -1;
- }
-}
-void loc_apicb_app_deinit(void)
-{
-
- if (svrPort == NULL)
- {
- return;
- }
-
-
- svc_unregister(svrPort, LOC_APICBPROG,LOC_APICBVERS_0001);
-}
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr
deleted file mode 100644
index 82dca56..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api.xdr
+++ /dev/null
@@ -1,261 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/* LOC_API TOOL VERSION: 4.48 */
-/* GENERATED: TUE JUN 14 2011 */
-/*=============================================================================
- L O C _ A P I . X D R
-
-GENERAL DESCRIPTION
- This is an AUTO GENERATED file that provides an xdr compatible definition of
- the loc_api API.
-
- ---------------------------------------------------------------------------
-
-
- ---------------------------------------------------------------------------
-=============================================================================*/
-
-/*=============================================================================
-
- Edit History
-
- AUTO GENERATED
-
-Generated by following versions of Htorpc modules:
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
-
-loc_api Definition File(s):
-Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
-=============================================================================*/
-/*=============================================================================
-$Header$
-=============================================================================*/
-
-
-
-typedef rpc_uint32 rpc_loc_api_api_versions_return_type<>;
-
-/*
- * Declare an rpc_uint32 type for each callback type in the API
- */
-typedef rpc_uint32 rpc_loc_event_cb_f_type;
-
-
-
-/*
- * These are struct declarations for the function arguments
- */
-
-struct rpc_loc_open_args {
- rpc_loc_event_mask_type event_reg_mask;
- rpc_loc_event_cb_f_type event_callback;
-};
-
-struct rpc_loc_close_args {
- rpc_loc_client_handle_type handle;
-};
-
-struct rpc_loc_start_fix_args {
- rpc_loc_client_handle_type handle;
-};
-
-struct rpc_loc_stop_fix_args {
- rpc_loc_client_handle_type handle;
-};
-
-struct rpc_loc_ioctl_args {
- rpc_loc_client_handle_type handle;
- rpc_loc_ioctl_e_type ioctl_type;
- rpc_loc_ioctl_data_u_type *ioctl_data;
-};
-
-
-
-struct rpc_loc_api_api_version_s_args {
- rpc_boolean len_not_null;
-};
-
-/*
- * These are struct declarations for the function results
- */
-
-struct rpc_loc_api_rpc_glue_code_info_remote_rets {
- rpc_uint32 toolvers; /* Tool version */
- rpc_uint32 features; /* Features turned on in the code.
- * 0x00000001 ONCRPC Server Cleanup Support
- */
- rpc_uint32 proghash; /* Unique hash value for the API XDR definition */
- rpc_uint32 cbproghash; /* Unique hash value for the Callbacks' XDR definition */
-};
-
-struct rpc_loc_open_rets {
- rpc_loc_client_handle_type loc_open_result;
-};
-
-struct rpc_loc_close_rets {
- rpc_int32 loc_close_result;
-};
-
-struct rpc_loc_start_fix_rets {
- rpc_int32 loc_start_fix_result;
-};
-
-struct rpc_loc_stop_fix_rets {
- rpc_int32 loc_stop_fix_result;
-};
-
-struct rpc_loc_ioctl_rets {
- rpc_int32 loc_ioctl_result;
-};
-
- struct rpc_loc_api_api_versions_rets {
- rpc_loc_api_api_versions_return_type loc_api_api_versions_result;
- rpc_uint32 *len;
-};
-
-/*
- * XDR definition of the LOC_API program ( vers. 0x00050006 )
- */
-
-program LOC_APIPROG {
- version LOC_APIVERS_0001 {
-
- void
- rpc_loc_api_null( void ) = 0;
-
- rpc_loc_api_rpc_glue_code_info_remote_rets
- rpc_loc_api_rpc_glue_code_info_remote( void ) = 1;
-
- rpc_loc_open_rets
- rpc_loc_open( rpc_loc_open_args ) = 2;
-
- rpc_loc_close_rets
- rpc_loc_close( rpc_loc_close_args ) = 3;
-
- rpc_loc_start_fix_rets
- rpc_loc_start_fix( rpc_loc_start_fix_args ) = 4;
-
- rpc_loc_stop_fix_rets
- rpc_loc_stop_fix( rpc_loc_stop_fix_args ) = 5;
-
- rpc_loc_ioctl_rets
- rpc_loc_ioctl( rpc_loc_ioctl_args ) = 6;
-
- rpc_loc_api_api_versions_rets
- rpc_loc_api_api_versions( void ) = 0xFFFFFFFF;
-
-
-
-
- } = 0x00050001;
-
-version LOC_APIVERS_0002 {
-
-/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
-RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
-*/
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
-RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
-RPC_LOC_IOCTL_RESERVED_CMD
-RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
-*/
-
- void
- rpc_loc_api_null( void ) = 0;
-
- } = 0x00050002;
-
-version LOC_APIVERS_0003 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
-RPC_LOC_IOCTL_SET_DATA_ENABLE
-RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
-RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
-RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
-RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
-*/
-
- void
- rpc_loc_api_null( void ) = 0;
-
- } = 0x00050003;
-
-version LOC_APIVERS_0004 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
-RPC_LOC_IOCTL_GET_SUPL_VERSION
-RPC_LOC_IOCTL_SET_SUPL_VERSION
-*/
-
- void
- rpc_loc_api_null( void ) = 0;
-
- } = 0x00050004;
-
-version LOC_APIVERS_0005 {
-
-/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
-RPC_LOC_SERVER_ADDR_IPV6
-*/
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
-RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
-*/
-
- void
- rpc_loc_api_null( void ) = 0;
-
- } = 0x00050005;
-
-
-
- version LOC_APIVERS_0006 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
-RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
-*/
-/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
-RPC_LOC_SERVER_REQUEST_MULTI_OPEN
-*/
-
- void
- rpc_loc_api_null( void ) = 0;
-
- } = 0x00050006;
-
-
-} = 0x3000008C;
-
-const LOC_APIVERS = 0x00050006;
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr
deleted file mode 100644
index 4756c6c..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_cb.xdr
+++ /dev/null
@@ -1,187 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/* LOC_API TOOL VERSION: 4.48 */
-/* GENERATED: TUE JUN 14 2011 */
-/*=============================================================================
- L O C _ A P I _ C B . X D R
-
-GENERAL DESCRIPTION
- This is an AUTO GENERATED file that provides an xdr compatible definition of
- an api that represents the grouping of the different callback functions the
- loc_api API supports.
-
- ---------------------------------------------------------------------------
-
-
- ---------------------------------------------------------------------------
-=============================================================================*/
-
-/*=============================================================================
-
- Edit History
-
- AUTO GENERATED
-
-Generated by following versions of Htorpc modules:
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
-
-loc_api Definition File(s):
-Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
-=============================================================================*/
-/*=============================================================================
-$Header$
-=============================================================================*/
-
-
-
-
-/*
- * These are struct declarations for the function arguments
- */
-
-struct rpc_loc_event_cb_f_type_args {
- rpc_uint32 cb_id;
- rpc_loc_client_handle_type loc_handle;
- rpc_loc_event_mask_type loc_event;
- rpc_loc_event_payload_u_type *loc_event_payload;
-};
-
-
-
-
-
-/*
- * These are struct declaratios for the function results
- */
-
-struct rpc_loc_event_cb_f_type_rets {
- rpc_int32 loc_event_cb_f_type_result;
-};
-
-
-
-/*
- * XDR definition of the LOC_API callback program ( vers. 0x00050006 )
- */
-
-program LOC_APICBPROG {
- version LOC_APICBVERS_0001 {
-
- rpc_loc_event_cb_f_type_rets
- rpc_loc_event_cb_f_type( rpc_loc_event_cb_f_type_args ) = 1;
-
-
-
-
- } = 0x00050001;
-
-version LOC_APICBVERS_0002 {
-
-/* Following elements added in enum rpc_loc_assist_data_request_e_type in 0x00050002
-RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ
-*/
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050002
-RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL
-RPC_LOC_IOCTL_RESERVED_CMD
-RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL
-*/
-
- int
- rpc_loc_api_cb_null( void ) = 0xffffff00;
-
- } = 0x00050002;
-
-version LOC_APICBVERS_0003 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050003
-RPC_LOC_IOCTL_SET_DATA_ENABLE
-RPC_LOC_IOCTL_SET_LBS_APN_PROFILE
-RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE
-RPC_LOC_IOCTL_GET_LBS_APN_PROFILE
-RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE
-*/
-
- int
- rpc_loc_api_cb_null( void ) = 0xffffff00;
-
- } = 0x00050003;
-
-version LOC_APICBVERS_0004 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050004
-RPC_LOC_IOCTL_GET_SUPL_VERSION
-RPC_LOC_IOCTL_SET_SUPL_VERSION
-*/
-
- int
- rpc_loc_api_cb_null( void ) = 0xffffff00;
-
- } = 0x00050004;
-
-version LOC_APICBVERS_0005 {
-
-/* Following elements added in enum rpc_loc_server_addr_e_type in 0x00050005
-RPC_LOC_SERVER_ADDR_IPV6
-*/
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050005
-RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG
-*/
-
- int
- rpc_loc_api_cb_null( void ) = 0xffffff00;
-
- } = 0x00050005;
-
-
-
- version LOC_APICBVERS_0006 {
-
-/* Following elements added in enum rpc_loc_ioctl_e_type in 0x00050006
-RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS
-*/
-/* Following elements added in enum rpc_loc_server_request_e_type in 0x00050006
-RPC_LOC_SERVER_REQUEST_MULTI_OPEN
-*/
-
- int
- rpc_loc_api_cb_null( void ) = 0xffffff00;
-
- } = 0x00050006;
-
-
-} = 0x3100008C;
-
-const LOC_APICBVERS = 0x00050006;
diff --git a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr b/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr
deleted file mode 100644
index e059c66..0000000
--- a/msm8998/loc_api/libloc_api-rpc-50001/libloc_api-rpc-stub/xdr/loc_api_common.xdr
+++ /dev/null
@@ -1,1021 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/* LOC_API TOOL VERSION: 4.48 */
-/* GENERATED: TUE JUN 14 2011 */
-/*=============================================================================
- L O C _ A P I _ C O M M O N . X D R
-
-GENERAL DESCRIPTION
- This is an AUTO GENERATED file that provides an xdr compatible definition of
- an api that represents the grouping of the different callback functions the
- loc_api API supports.
-
- ---------------------------------------------------------------------------
-
-
- ---------------------------------------------------------------------------
-=============================================================================*/
-
-/*=============================================================================
-
- Edit History
-
- AUTO GENERATED
-
-Generated by following versions of Htorpc modules:
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/htorpc.pl#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Start.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Htoxdr.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/XDR.pm#3
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Output.pm#5
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Parser.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/Metacomments.pm#1
-Id: //source/qcom/qct/core/mproc/tools/rel/2h09/htorpc/lib/Htorpc/SymbolTable.pm#1
-
-loc_api Definition File(s):
-Id: //source/qcom/qct/modem/api/gps/main/latest/loc_api.h#24
-=============================================================================*/
-/*=============================================================================
-$Header$
-=============================================================================*/
-
-
-
-const LOC_API_TOOLVERS = 0x00040030;
-const LOC_API_FEATURES = 0x00000001;
-
-const RPC_LOC_EVENT_STATUS_REPORT = 0x00000100;
-
-const RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST = 0x00000020;
-
-const RPC_LOC_EVENT_WPS_NEEDED_REQUEST = 0x00000200;
-
-const RPC_LOC_EVENT_SATELLITE_REPORT = 0x00000002;
-
-const RPC_LOC_EVENT_PARSED_POSITION_REPORT = 0x00000001;
-
-const RPC_LOC_EVENT_RESERVED = 0x8000000000000000;
-
-const RPC_LOC_EVENT_LOCATION_SERVER_REQUEST = 0x00000040;
-
-const RPC_LOC_EVENT_NMEA_POSITION_REPORT = 0x00000008;
-
-const RPC_LOC_EVENT_IOCTL_REPORT = 0x00000080;
-
-const RPC_LOC_EVENT_NMEA_1HZ_REPORT = 0x00000004;
-
-const RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST = 0x00000010;
-
-const RPC_LOC_API_CB_NULL_VERSION = 0x00050002;
-const RPC_LOC_EVENT_CB_F_TYPE_VERSION = 0x00050001;
-const RPC_LOC_API_API_VERSIONS_VERSION = 0x00050001;
-const RPC_LOC_STOP_FIX_VERSION = 0x00050001;
-const RPC_LOC_START_FIX_VERSION = 0x00050001;
-const RPC_LOC_IOCTL_VERSION = 0x00050001;
-const RPC_LOC_CLOSE_VERSION = 0x00050001;
-const RPC_LOC_API_RPC_GLUE_CODE_INFO_REMOTE_VERSION = 0x00050001;
-const RPC_LOC_OPEN_VERSION = 0x00050001;
-const RPC_LOC_API_NULL_VERSION = 0x00050001;
-const RPC_LOC_API_API_MAJOR_NUM = 0x0005;
-const RPC_LOC_APIAPI_VERSION_IS_HASHKEY = 0;
-
-typedef rpc_int32 rpc_loc_client_handle_type;
-
-typedef rpc_uint64 rpc_loc_event_mask_type;
-
-typedef rpc_uint64 rpc_loc_position_valid_mask_type;
-
-typedef rpc_uint32 rpc_loc_pos_technology_mask_type;
-
-enum rpc_loc_session_status_e_type {
- RPC_LOC_SESS_STATUS_SUCCESS = 0,
- RPC_LOC_SESS_STATUS_IN_PROGESS = 1,
- RPC_LOC_SESS_STATUS_GENERAL_FAILURE = 2,
- RPC_LOC_SESS_STATUS_TIMEOUT = 3,
- RPC_LOC_SESS_STATUS_USER_END = 4,
- RPC_LOC_SESS_STATUS_BAD_PARAMETER = 5,
- RPC_LOC_SESS_STATUS_PHONE_OFFLINE = 6,
- RPC_LOC_SESS_STATUS_ENGINE_LOCKED = 7,
- RPC_LOC_SESS_STATUS_MAX = 268435456
-};
-
-struct rpc_loc_calendar_time_s_type {
- rpc_uint16 year;
- unsigned char month;
- unsigned char day_of_week;
- unsigned char day;
- unsigned char hour;
- unsigned char minute;
- unsigned char second;
- rpc_uint16 millisecond;
-};
-
-struct rpc_loc_parsed_position_s_type {
- rpc_loc_position_valid_mask_type valid_mask;
- rpc_loc_session_status_e_type session_status;
- rpc_loc_calendar_time_s_type timestamp_calendar;
- rpc_uint64 timestamp_utc;
- rpc_uint8 leap_seconds;
- float time_unc;
- double latitude;
- double longitude;
- float altitude_wrt_ellipsoid;
- float altitude_wrt_mean_sea_level;
- float speed_horizontal;
- float speed_vertical;
- float heading;
- float hor_unc_circular;
- float hor_unc_ellipse_semi_major;
- float hor_unc_ellipse_semi_minor;
- float hor_unc_ellipse_orient_azimuth;
- float vert_unc;
- float speed_unc;
- float heading_unc;
- unsigned char confidence_horizontal;
- unsigned char confidence_vertical;
- float magnetic_deviation;
- rpc_loc_pos_technology_mask_type technology_mask;
-};
-
-enum rpc_loc_sv_system_e_type {
- RPC_LOC_SV_SYSTEM_GPS = 1,
- RPC_LOC_SV_SYSTEM_GALILEO = 2,
- RPC_LOC_SV_SYSTEM_SBAS = 3,
- RPC_LOC_SV_SYSTEM_COMPASS = 4,
- RPC_LOC_SV_SYSTEM_GLONASS = 5,
- RPC_LOC_SV_SYSTEM_MAX = 268435456
-};
-
-enum rpc_loc_sv_status_e_type {
- RPC_LOC_SV_STATUS_IDLE = 1,
- RPC_LOC_SV_STATUS_SEARCH = 2,
- RPC_LOC_SV_STATUS_TRACK = 3,
- RPC_LOC_SV_STATUS_MAX = 268435456
-};
-
-typedef rpc_uint32 rpc_loc_sv_info_valid_mask_type;
-
-struct rpc_loc_sv_info_s_type {
- rpc_loc_sv_info_valid_mask_type valid_mask;
- rpc_loc_sv_system_e_type system;
- rpc_uint8 prn;
- rpc_uint8 health_status;
- rpc_loc_sv_status_e_type process_status;
- rpc_boolean has_eph;
- rpc_boolean has_alm;
- float elevation;
- float azimuth;
- float snr;
-};
-
-typedef rpc_uint32 rpc_loc_gnss_info_valid_mask_type;
-
-struct rpc_loc_gnss_info_s_type {
- rpc_loc_gnss_info_valid_mask_type valid_mask;
- float position_dop;
- float horizontal_dop;
- float vertical_dop;
- rpc_boolean altitude_assumed;
- rpc_uint16 sv_count;
- rpc_loc_sv_info_s_type sv_list<80>; /* EVAL:[LOC_API_MAX_SV_COUNT]*/
-};
-
-struct rpc_loc_nmea_report_s_type {
- rpc_uint16 length;
- opaque nmea_sentences[200];
-};
-
-enum rpc_loc_status_event_e_type {
- RPC_LOC_STATUS_EVENT_ENGINE_STATE = 1,
- RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE = 2,
- RPC_LOC_STATUS_EVENT_MAX = 268435456
-};
-
-enum rpc_loc_engine_state_e_type {
- RPC_LOC_ENGINE_STATE_ON = 1,
- RPC_LOC_ENGINE_STATE_OFF = 2,
- RPC_LOC_ENGINE_STATE_MAX = 268435456
-};
-
-enum rpc_loc_fix_session_state_e_type {
- RPC_LOC_FIX_SESSION_STATE_BEGIN = 1,
- RPC_LOC_FIX_SESSION_STATE_END = 2,
- RPC_LOC_FIX_SESSION_STATE_MAX = 268435456
-};
-
-union rpc_loc_status_event_payload_u_type switch (rpc_loc_status_event_e_type disc) {
- case RPC_LOC_STATUS_EVENT_ENGINE_STATE:
- rpc_loc_engine_state_e_type engine_state;
- case RPC_LOC_STATUS_EVENT_FIX_SESSION_STATE:
- rpc_loc_fix_session_state_e_type fix_session_state;
- default:
- void;
-};
-
-struct rpc_loc_status_event_s_type {
- rpc_loc_status_event_e_type event;
- rpc_loc_status_event_payload_u_type payload;
-};
-
-enum rpc_loc_server_addr_e_type {
- RPC_LOC_SERVER_ADDR_IPV4 = 1,
- RPC_LOC_SERVER_ADDR_URL = 2,
- RPC_LOC_SERVER_ADDR_IPV6 = 3,
- RPC_LOC_SERVER_ADDR_MAX = 268435456
-};
-
-struct rpc_loc_server_addr_ipv4_type {
- rpc_uint32 addr;
- rpc_uint16 port;
-};
-
-struct rpc_loc_server_addr_url_type {
- rpc_uint16 length;
- opaque addr[256];
-};
-
-struct rpc_loc_server_addr_ipv6_type {
- rpc_uint16 addr[8];
- rpc_uint32 port;
-};
-
-union rpc_loc_server_addr_u_type switch (rpc_loc_server_addr_e_type disc) {
- case RPC_LOC_SERVER_ADDR_IPV4:
- rpc_loc_server_addr_ipv4_type ipv4;
- case RPC_LOC_SERVER_ADDR_URL:
- rpc_loc_server_addr_url_type url;
- case RPC_LOC_SERVER_ADDR_IPV6:
- rpc_loc_server_addr_ipv6_type ipv6;
- default:
- void;
-};
-
-struct rpc_loc_server_info_s_type {
- rpc_loc_server_addr_e_type addr_type;
- rpc_loc_server_addr_u_type addr_info;
-};
-
-enum rpc_loc_ni_notify_verify_e_type {
- RPC_LOC_NI_USER_NO_NOTIFY_NO_VERIFY = 1,
- RPC_LOC_NI_USER_NOTIFY_ONLY = 2,
- RPC_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP = 3,
- RPC_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP = 4,
- RPC_LOC_NI_USER_PRIVACY_OVERRIDE = 5,
- RPC_LOC_NI_USER_NOTIFY_VERITY_TYPE_MAX = 268435456
-};
-
-enum rpc_loc_ni_event_e_type {
- RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ = 1,
- RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ = 2,
- RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ = 3,
- RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ = 4,
- RPC_LOC_NI_EVENT_MAX = 268435456
-};
-
-enum rpc_loc_ni_datacoding_scheme_e_type {
- RPC_LOC_NI_PRESUPL_ISO646IRV = 0,
- RPC_LOC_NI_PRESUPL_ISO8859 = 1,
- RPC_LOC_NI_PRESUPL_UTF8 = 2,
- RPC_LOC_NI_PRESUPL_UTF16 = 3,
- RPC_LOC_NI_PRESUPL_UCS2 = 4,
- RPC_LOC_NI_PRESUPL_GSM_DEFAULT = 5,
- RPC_LOC_NI_PRESUPL_SHIFT_JIS = 6,
- RPC_LOC_NI_PRESUPL_JIS = 7,
- RPC_LOC_NI_PRESUPL_EUC = 8,
- RPC_LOC_NI_PRESUPL_GB2312 = 9,
- RPC_LOC_NI_PRESUPL_CNS11643 = 10,
- RPC_LOC_NI_PRESUPL_KSC1001 = 11,
- RPC_LOC_NI_PRESUPL_ENCODING_UNKNOWN = 2147483647,
- RPC_LOC_NI_SS_GERMAN = 12,
- RPC_LOC_NI_SS_ENGLISH = 13,
- RPC_LOC_NI_SS_ITALIAN = 14,
- RPC_LOC_NI_SS_FRENCH = 15,
- RPC_LOC_NI_SS_SPANISH = 16,
- RPC_LOC_NI_SS_DUTCH = 17,
- RPC_LOC_NI_SS_SWEDISH = 18,
- RPC_LOC_NI_SS_DANISH = 19,
- RPC_LOC_NI_SS_PORTUGUESE = 20,
- RPC_LOC_NI_SS_FINNISH = 21,
- RPC_LOC_NI_SS_NORWEGIAN = 22,
- RPC_LOC_NI_SS_GREEK = 23,
- RPC_LOC_NI_SS_TURKISH = 24,
- RPC_LOC_NI_SS_HUNGARIAN = 25,
- RPC_LOC_NI_SS_POLISH = 26,
- RPC_LOC_NI_SS_LANGUAGE_UNSPEC = 27,
- RPC_LOC_NI_SUPL_UTF8 = 28,
- RPC_LOC_NI_SUPL_UCS2 = 29,
- RPC_LOC_NI_SUPL_GSM_DEFAULT = 30,
- RPC_LOC_NI_SUPL_ENCODING_UNKNOWN = 2147483647
-};
-
-enum rpc_loc_ni_vx_requester_id_encoding_scheme_e_type {
- RPC_LOC_NI_VX_OCTET = 0,
- RPC_LOC_NI_VX_EXN_PROTOCOL_MSG = 1,
- RPC_LOC_NI_VX_ASCII = 2,
- RPC_LOC_NI_VX_IA5 = 3,
- RPC_LOC_NI_VX_UNICODE = 4,
- RPC_LOC_NI_VX_SHIFT_JIS = 5,
- RPC_LOC_NI_VX_KOREAN = 6,
- RPC_LOC_NI_VX_LATIN_HEBREW = 7,
- RPC_LOC_NI_VX_LATIN = 8,
- RPC_LOC_NI_VX_GSM = 9,
- RPC_LOC_NI_VX_ENCODING_TYPE_MAX = 268435456
-};
-
-enum rpc_loc_ni_vx_pos_mode_e_type {
- RPC_LOC_VX_MS_ASSISTED_ONLY = 1,
- RPC_LOC_VX_MS_BASED_ONLY = 2,
- RPC_LOC_VX_MS_ASSISTED_PREF_MSBASED_ALLWD = 3,
- RPC_LOC_VX_MS_BASED_PREF_ASSISTED_ALLWD = 4,
- RPC_LOC_VX_POS_MODE_MAX = 268435456
-};
-
-struct rpc_loc_ni_vx_requester_id_s_type {
- unsigned char requester_id_length;
- opaque requester_id[200];
-};
-
-struct rpc_loc_ni_vx_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- unsigned char pos_qos_incl;
- unsigned char pos_qos;
- rpc_uint32 num_fixes;
- rpc_uint32 tbf;
- rpc_loc_ni_vx_pos_mode_e_type pos_mode;
- rpc_loc_ni_vx_requester_id_encoding_scheme_e_type encoding_scheme;
- rpc_loc_ni_vx_requester_id_s_type requester_id;
- rpc_uint16 user_resp_timer_val;
-};
-
-enum rpc_loc_ni_supl_pos_method_e_type {
- RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED = 1,
- RPC_LOC_NI_POSMETHOD_AGPS_SETBASED = 2,
- RPC_LOC_NI_POSMETHOD_AGPS_SETASSISTED_PREF = 3,
- RPC_LOC_NI_POSMETHOD_AGPS_SETBASED_PREF = 4,
- RPC_LOC_NI_POSMETHOD_AUTONOMOUS_GPS = 5,
- RPC_LOC_NI_POSMETHOD_AFLT = 6,
- RPC_LOC_NI_POSMETHOD_ECID = 7,
- RPC_LOC_NI_POSMETHOD_EOTD = 8,
- RPC_LOC_NI_POSMETHOD_OTDOA = 9,
- RPC_LOC_NI_POSMETHOD_NO_POSITION = 10,
- RPC_LOC_NI_POSMETHOD_MAX = 268435456
-};
-
-struct rpc_loc_ni_supl_slp_session_id_s_type {
- unsigned char presence;
- opaque session_id[4];
- rpc_loc_server_info_s_type slp_address;
-};
-
-struct rpc_loc_ni_requestor_id_s_type {
- unsigned char data_coding_scheme;
- opaque requestor_id_string[200];
- unsigned char string_len;
-};
-
-struct rpc_loc_ni_supl_client_name_s_type {
- unsigned char data_coding_scheme;
- opaque client_name_string[64];
- unsigned char string_len;
-};
-
-struct rpc_loc_ni_supl_qop_s_type {
- unsigned char bit_mask;
- unsigned char horacc;
- unsigned char veracc;
- rpc_uint16 maxLocAge;
- unsigned char delay;
-};
-
-struct rpc_loc_ni_supl_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- rpc_uint16 flags;
- rpc_loc_ni_supl_slp_session_id_s_type supl_slp_session_id;
- opaque supl_hash[8];
- rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
- rpc_loc_ni_supl_pos_method_e_type pos_method;
- rpc_loc_ni_requestor_id_s_type requestor_id;
- rpc_loc_ni_supl_client_name_s_type client_name;
- rpc_loc_ni_supl_qop_s_type supl_qop;
- rpc_uint16 user_response_timer;
-};
-
-struct rpc_loc_ni_ext_client_address_s_type {
- unsigned char ext_client_address_len;
- opaque ext_client_address[20];
-};
-
-enum rpc_loc_ni_location_type_e_type {
- RPC_LOC_NI_LOCATIONTYPE_CURRENT_LOCATION = 1,
- RPC_LOC_NI_LOCATIONTYPE_CURRENT_OR_LAST_KNOWN_LOCATION = 2,
- RPC_LOC_NI_LOCATIONTYPE_INITIAL_LOCATION = 3,
- RPC_LOC_NI_LOCATIONTYPE_MAX = 268435456
-};
-
-struct rpc_loc_ni_deferred_location_s_type {
- unsigned char unused_bits;
- unsigned char ms_available;
-};
-
-struct rpc_loc_ni_codeword_string_s_type {
- unsigned char data_coding_scheme;
- opaque lcs_codeword_string[20];
- unsigned char string_len;
-};
-
-struct rpc_loc_ni_service_type_id_s_type {
- unsigned char lcs_service_type_id;
-};
-
-struct rpc_loc_ni_umts_cp_notify_verify_req_s_type {
- rpc_loc_ni_notify_verify_e_type notification_priv_type;
- unsigned char invoke_id;
- rpc_uint16 flags;
- unsigned char notification_length;
- opaque notification_text[64];
- rpc_loc_ni_datacoding_scheme_e_type datacoding_scheme;
- rpc_loc_ni_ext_client_address_s_type ext_client_address_data;
- rpc_loc_ni_location_type_e_type location_type;
- rpc_loc_ni_deferred_location_s_type deferred_location;
- rpc_loc_ni_requestor_id_s_type requestor_id;
- rpc_loc_ni_codeword_string_s_type codeword_string;
- rpc_loc_ni_service_type_id_s_type service_type_id;
- rpc_uint16 user_response_timer;
-};
-
-enum rpc_loc_ni_service_interaction_e_type {
- RPC_LOC_NI_SERVICE_INTERACTION_ONGOING_NI_INCOMING_MO = 1,
- RPC_LOC_NI_SERVICE_INTERACTION_MAX = 268435456
-};
-
-struct rpc_loc_ni_vx_service_interaction_req_s_type {
- rpc_loc_ni_vx_notify_verify_req_s_type ni_vx_req;
- rpc_loc_ni_service_interaction_e_type service_interation_type;
-};
-
-union rpc_loc_ni_event_payload_u_type switch (rpc_loc_ni_event_e_type disc) {
- case RPC_LOC_NI_EVENT_VX_NOTIFY_VERIFY_REQ:
- rpc_loc_ni_vx_notify_verify_req_s_type vx_req;
- case RPC_LOC_NI_EVENT_SUPL_NOTIFY_VERIFY_REQ:
- rpc_loc_ni_supl_notify_verify_req_s_type supl_req;
- case RPC_LOC_NI_EVENT_UMTS_CP_NOTIFY_VERIFY_REQ:
- rpc_loc_ni_umts_cp_notify_verify_req_s_type umts_cp_req;
- case RPC_LOC_NI_EVENT_VX_SERVICE_INTERACTION_REQ:
- rpc_loc_ni_vx_service_interaction_req_s_type service_interaction_req;
- default:
- void;
-};
-
-struct rpc_loc_ni_event_s_type {
- rpc_loc_ni_event_e_type event;
- rpc_loc_ni_event_payload_u_type payload;
-};
-
-enum rpc_loc_assist_data_request_e_type {
- RPC_LOC_ASSIST_DATA_TIME_REQ = 1,
- RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ = 2,
- RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ = 3,
- RPC_LOC_ASSIST_DATA_MAX = 268435456
-};
-
-typedef string rpc_struct_loc_time_download_source_s_type_servers_ptr<256>; /* EVAL:[LOC_API_MAX_SERVER_ADDR_LENGTH]*/
-
-typedef rpc_struct_loc_time_download_source_s_type_servers_ptr rpc_struct_loc_time_download_source_s_type_servers[3];
-
-struct rpc_loc_time_download_source_s_type {
- rpc_uint32 delay_threshold;
- rpc_struct_loc_time_download_source_s_type_servers servers;
-};
-
-typedef string rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr<LOC_API_MAX_SERVER_ADDR_LENGTH>;
-
-typedef rpc_struct_loc_predicted_orbits_data_source_s_type_servers_ptr rpc_struct_loc_predicted_orbits_data_source_s_type_servers[3];
-
-struct rpc_loc_predicted_orbits_data_source_s_type {
- rpc_uint32 max_file_size;
- rpc_uint32 max_part_size;
- rpc_struct_loc_predicted_orbits_data_source_s_type_servers servers;
-};
-
-struct rpc_loc_pos_inj_request_s_type {
- rpc_uint32 flags;
- double latitude;
- double longitude;
- rpc_uint32 position_uncertainty;
- rpc_uint64 timestamp;
-};
-
-union rpc_loc_assist_data_request_payload_u_type switch (rpc_loc_assist_data_request_e_type disc) {
- case RPC_LOC_ASSIST_DATA_TIME_REQ:
- rpc_loc_time_download_source_s_type time_download;
- case RPC_LOC_ASSIST_DATA_PREDICTED_ORBITS_REQ:
- rpc_loc_predicted_orbits_data_source_s_type data_download;
- case RPC_LOC_ASSIST_DATA_POSITION_INJECTION_REQ:
- rpc_loc_pos_inj_request_s_type pos_injection;
- default:
- void;
-};
-
-struct rpc_loc_assist_data_request_s_type {
- rpc_loc_assist_data_request_e_type event;
- rpc_loc_assist_data_request_payload_u_type payload;
-};
-
-typedef rpc_uint32 rpc_loc_server_connection_handle;
-
-enum rpc_loc_server_protocol_e_type {
- RPC_LOC_SERVER_PROTOCOL_DEFAULT = 0,
- RPC_LOC_SERVER_PROTOCOL_SUPL = 1,
- RPC_LOC_SERVER_PROTOCOL_VX_MPC = 2,
- RPC_LOC_SERVER_PROTOCOL_VX_PDE = 3,
- RPC_LOC_SERVER_PROTOCOL_MAX = 16777216
-};
-
-enum rpc_loc_server_connection_e_type {
- RPC_LOC_SERVER_CONNECTION_LBS = 0,
- RPC_LOC_SERVER_CONNECTION_WWAN_INTERNET,
- RPC_LOC_SERVER_CONNECTION_MAX = 16777216
-};
-
-enum rpc_loc_server_request_e_type {
- RPC_LOC_SERVER_REQUEST_OPEN = 1,
- RPC_LOC_SERVER_REQUEST_CLOSE = 2,
- RPC_LOC_SERVER_REQUEST_MULTI_OPEN = 3,
- RPC_LOC_SERVER_REQUEST_MAX = 268435456
-};
-
-struct rpc_loc_server_open_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_protocol_e_type protocol;
-};
-
-struct rpc_loc_server_multi_open_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_protocol_e_type protocol;
- rpc_loc_server_connection_e_type connection_type;
-};
-
-struct rpc_loc_server_close_req_s_type {
- rpc_loc_server_connection_handle conn_handle;
-};
-
-union rpc_loc_server_request_u_type switch (rpc_loc_server_request_e_type disc) {
- case RPC_LOC_SERVER_REQUEST_OPEN:
- rpc_loc_server_open_req_s_type open_req;
- case RPC_LOC_SERVER_REQUEST_CLOSE:
- rpc_loc_server_close_req_s_type close_req;
- case RPC_LOC_SERVER_REQUEST_MULTI_OPEN:
- rpc_loc_server_multi_open_req_s_type multi_open_req;
- default:
- void;
-};
-
-struct rpc_loc_server_request_s_type {
- rpc_loc_server_request_e_type event;
- rpc_loc_server_request_u_type payload;
-};
-
-enum rpc_loc_qwip_request_e_type {
- RPC_LOC_QWIP_START_PERIODIC_HI_FREQ_FIXES = 0,
- RPC_LOC_QWIP_START_PERIODIC_KEEP_WARM,
- RPC_LOC_QWIP_STOP_PERIODIC_FIXES,
- RPC_LOC_QWIP_SUSPEND,
- RPC_LOC_QWIP_REQUEST_MAX = 268435456
-};
-
-struct rpc_loc_qwip_request_s_type {
- rpc_loc_qwip_request_e_type request_type;
- rpc_uint16 tbf_ms;
-};
-
-struct rpc_loc_reserved_payload_s_type {
- rpc_uint16 data_size;
- opaque data<>;
-};
-
-enum rpc_loc_ioctl_e_type {
- RPC_LOC_IOCTL_GET_API_VERSION = 1,
- RPC_LOC_IOCTL_SET_FIX_CRITERIA = 2,
- RPC_LOC_IOCTL_GET_FIX_CRITERIA = 3,
- RPC_LOC_IOCTL_SERVICE_START_INDEX = 400,
- RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE = 400,
- RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA = 401,
- RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY = 402,
- RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE = 403,
- RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD = 404,
- RPC_LOC_IOCTL_INJECT_UTC_TIME = 405,
- RPC_LOC_IOCTL_INJECT_RTC_VALUE = 406,
- RPC_LOC_IOCTL_INJECT_POSITION = 407,
- RPC_LOC_IOCTL_QUERY_ENGINE_STATE = 408,
- RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS = 409,
- RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS = 410,
- RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT = 411,
- RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS = 412,
- RPC_LOC_IOCTL_ACCESS_EFS_DATA = 413,
- RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG = 414,
- RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS = 415,
- RPC_LOC_IOCTL_NV_SETTINGS_START_INDEX = 800,
- RPC_LOC_IOCTL_SET_ENGINE_LOCK = 800,
- RPC_LOC_IOCTL_GET_ENGINE_LOCK = 801,
- RPC_LOC_IOCTL_SET_SBAS_CONFIG = 802,
- RPC_LOC_IOCTL_GET_SBAS_CONFIG = 803,
- RPC_LOC_IOCTL_SET_NMEA_TYPES = 804,
- RPC_LOC_IOCTL_GET_NMEA_TYPES = 805,
- RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR = 806,
- RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR = 807,
- RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR = 808,
- RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR = 809,
- RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR = 810,
- RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR = 811,
- RPC_LOC_IOCTL_SET_ON_DEMAND_LPM = 812,
- RPC_LOC_IOCTL_GET_ON_DEMAND_LPM = 813,
- RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL = 814,
- RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL = 815,
- RPC_LOC_IOCTL_SET_LBS_APN_PROFILE = 816,
- RPC_LOC_IOCTL_GET_LBS_APN_PROFILE = 817,
- RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE = 818,
- RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE = 819,
- RPC_LOC_IOCTL_SET_DATA_ENABLE = 820,
- RPC_LOC_IOCTL_SET_SUPL_VERSION = 821,
- RPC_LOC_IOCTL_GET_SUPL_VERSION = 822,
- RPC_LOC_IOCTL_PROPRIETARY_START_INDEX = 1000,
- RPC_LOC_IOCTL_DELETE_ASSIST_DATA = 1000,
- RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR = 1001,
- RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR = 1002,
- RPC_LOC_IOCTL_RESERVED_CMD = 8000,
- RPC_LOC_IOCTL_THIRD_PARTY_START_INDEX = 1073741824
-};
-
-struct rpc_loc_api_version_s_type {
- unsigned char major;
- unsigned char minor;
-};
-
-enum rpc_loc_fix_recurrence_e_type {
- RPC_LOC_PERIODIC_FIX = 1,
- RPC_LOC_SINGLE_FIX = 2,
- RPC_LOC_FIX_SESSION_TYPE_MAX = 268435456
-};
-
-enum rpc_loc_operation_mode_e_type {
- RPC_LOC_OPER_MODE_DEFAULT = 1,
- RPC_LOC_OPER_MODE_MSB = 2,
- RPC_LOC_OPER_MODE_MSA = 3,
- RPC_LOC_OPER_MODE_STANDALONE = 4,
- RPC_LOC_OPER_MODE_SPEED_OPTIMAL = 5,
- RPC_LOC_OPER_MODE_ACCURACY_OPTIMAL = 6,
- RPC_LOC_OPER_MODE_DATA_OPTIMAL = 7,
- RPC_LOC_OPER_MODE_CELL_ID = 8,
- RPC_LOC_OPER_MODE_MAX = 268435456
-};
-
-enum rpc_loc_notify_e_type {
- RPC_LOC_NOTIFY_ON_INTERVAL = 1,
- RPC_LOC_NOTIFY_ON_DISTANCE = 2,
- RPC_LOC_NOTIFY_ON_ANY = 3,
- RPC_LOC_NOTIFY_ON_ALL = 4,
- RPC_LOC_NOTIFY_TYPE_MAX = 268435456
-};
-
-struct rpc_loc_fix_criteria_s_type {
- rpc_uint32 valid_mask;
- rpc_loc_fix_recurrence_e_type recurrence_type;
- rpc_loc_operation_mode_e_type preferred_operation_mode;
- rpc_uint32 preferred_accuracy;
- rpc_uint32 preferred_response_time;
- rpc_boolean intermediate_pos_report_enabled;
- rpc_loc_notify_e_type notify_type;
- rpc_uint32 min_interval;
- float min_distance;
- rpc_uint32 min_dist_sample_interval;
-};
-
-enum rpc_loc_ni_user_resp_e_type {
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT = 1,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_DENY = 2,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_NORESP = 3,
- RPC_LOC_NI_LCS_NOTIFY_VERIFY_MAX = 268435456
-};
-
-struct rpc_loc_user_verify_s_type {
- rpc_loc_ni_user_resp_e_type user_resp;
- rpc_loc_ni_event_s_type ni_event_pass_back;
-};
-
-enum rpc_loc_predicted_orbits_data_format_e_type {
- RPC_LOC_PREDICTED_ORBITS_XTRA = 0,
- RPC_LOC_PREDICTED_ORBITS_FORMAT_MAX = 268435456
-};
-
-struct rpc_loc_predicted_orbits_data_s_type {
- rpc_loc_predicted_orbits_data_format_e_type format_type;
- rpc_uint32 total_size;
- rpc_uint8 total_parts;
- rpc_uint8 part;
- rpc_uint16 part_len;
- opaque data_ptr<>;
-};
-
-struct rpc_loc_predicted_orbits_data_validity_report_s_type {
- rpc_uint64 start_time_utc;
- rpc_uint16 valid_duration_hrs;
-};
-
-struct rpc_loc_predicted_orbits_auto_download_config_s_type {
- rpc_boolean enable;
- unsigned char auto_check_every_hrs;
-};
-
-struct rpc_loc_assist_data_time_s_type {
- rpc_uint64 time_utc;
- rpc_uint32 uncertainty;
-};
-
-typedef rpc_uint64 rpc_loc_assist_pos_valid_mask_type;
-
-struct rpc_loc_assist_data_pos_s_type {
- rpc_loc_assist_pos_valid_mask_type valid_mask;
- rpc_uint64 timestamp_utc;
- double latitude;
- double longitude;
- float altitude_wrt_ellipsoid;
- float altitude_wrt_mean_sea_level;
- float hor_unc_circular;
- float vert_unc;
- unsigned char confidence_horizontal;
- unsigned char confidence_vertical;
- rpc_int32 timestamp_age;
-};
-
-enum rpc_loc_server_open_status_e_type {
- RPC_LOC_SERVER_OPEN_SUCCESS = 1,
- RPC_LOC_SERVER_OPEN_FAIL = 2,
- RPC_LOC_SERVER_OPEN_STATUS_MAX = 268435456
-};
-
-enum rpc_loc_server_pdp_type_e_type {
- RPC_LOC_SERVER_PDP_IP = 0,
- RPC_LOC_SERVER_PDP_PPP,
- RPC_LOC_SERVER_PDP_IPV6,
- RPC_LOC_SERVER_PDP_IPV4V6,
- RPC_LOC_SERVER_PDP_MAX = 268435456
-};
-
-struct rpc_loc_server_open_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_open_status_e_type open_status;
- opaque apn_name[100];
-};
-
-struct rpc_loc_server_multi_open_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_open_status_e_type open_status;
- rpc_loc_server_pdp_type_e_type pdp_type;
- opaque apn_name[100];
-};
-
-enum rpc_loc_server_close_status_e_type {
- RPC_LOC_SERVER_CLOSE_SUCCESS = 1,
- RPC_LOC_SERVER_CLOSE_FAIL = 2,
- RPC_LOC_SERVER_CLOSE_STATUS_MAX = 268435456
-};
-
-struct rpc_loc_server_close_status_s_type {
- rpc_loc_server_connection_handle conn_handle;
- rpc_loc_server_close_status_e_type close_status;
-};
-
-struct rpc_loc_wiper_fix_time_s_type {
- rpc_uint32 slow_clock_count;
-};
-
-struct rpc_loc_wiper_fix_pos_s_type {
- rpc_int32 lat;
- rpc_int32 lon;
- rpc_uint16 HEPE;
- rpc_uint8 num_of_aps_used;
- rpc_uint8 fix_error_code;
-};
-
-struct rpc_loc_wiper_ap_info_s_type {
- opaque mac_addr[6];
- rpc_int32 rssi;
- rpc_uint16 channel;
- rpc_uint8 ap_qualifier;
-};
-
-struct rpc_loc_wiper_ap_set_s_type {
- rpc_uint8 num_of_aps;
- rpc_loc_wiper_ap_info_s_type ap_info[50];
-};
-
-struct rpc_loc_wiper_position_report_s_type {
- rpc_uint8 wiper_valid_info_flag;
- rpc_loc_wiper_fix_time_s_type wiper_fix_time;
- rpc_loc_wiper_fix_pos_s_type wiper_fix_position;
- rpc_loc_wiper_ap_set_s_type wiper_ap_set;
-};
-
-enum rpc_loc_wiper_status_e_type {
- RPC_LOC_WIPER_STATUS_AVAILABLE = 1,
- RPC_LOC_WIPER_STATUS_UNAVAILABLE = 2,
- RPC_LOC_WIPER_STATUS_E_SIZE = 268435456
-};
-
-enum rpc_loc_fs_operation_e_type {
- RPC_LOC_FS_CREATE_WRITE_FILE = 1,
- RPC_LOC_FS_APPEND_FILE = 2,
- RPC_LOC_FS_DELETE_FILE = 3,
- RPC_LOC_FS_READ_FILE = 4,
- RPC_LOC_FS_MAX = 268435456
-};
-
-struct rpc_loc_efs_data_s_type {
- opaque filename[64];
- rpc_loc_fs_operation_e_type operation;
- rpc_uint32 total_size;
- opaque data_ptr<>;
- rpc_uint32 part_len;
- rpc_uint8 part;
- rpc_uint8 total_parts;
- rpc_uint32 reserved;
-};
-
-enum rpc_loc_error_estimate_config_e_type {
- RPC_LOC_ERROR_ESTIMATE_CONFIG_SET = 1,
- RPC_LOC_ERROR_ESTIMATE_CONFIG_CLEAR = 2,
- RPC_LOC_ERROR_ESTIMATE_MAX = 268435456
-};
-
-struct rpc_loc_apn_profiles_type {
- rpc_uint32 srv_system_type;
- rpc_uint32 pdp_type;
- rpc_uint32 reserved;
- opaque apn_name[100];
-};
-
-enum rpc_loc_lock_e_type {
- RPC_LOC_LOCK_NONE = 1,
- RPC_LOC_LOCK_MI = 2,
- RPC_LOC_LOCK_MT = 3,
- RPC_LOC_LOCK_ALL = 4,
- RPC_LOC_LOCK_MAX = 268435456
-};
-
-typedef rpc_uint32 rpc_loc_nmea_sentence_type;
-
-typedef rpc_uint32 rpc_loc_assist_data_type;
-
-struct rpc_loc_assist_data_delete_s_type {
- rpc_loc_assist_data_type type;
- rpc_uint32 reserved[8];
-};
-
-union rpc_loc_ioctl_data_u_type switch (rpc_loc_ioctl_e_type disc) {
- case RPC_LOC_IOCTL_SET_FIX_CRITERIA:
- rpc_loc_fix_criteria_s_type fix_criteria;
- case RPC_LOC_IOCTL_INFORM_NI_USER_RESPONSE:
- rpc_loc_user_verify_s_type user_verify_resp;
- case RPC_LOC_IOCTL_INJECT_PREDICTED_ORBITS_DATA:
- rpc_loc_predicted_orbits_data_s_type predicted_orbits_data;
- case RPC_LOC_IOCTL_SET_PREDICTED_ORBITS_DATA_AUTO_DOWNLOAD:
- rpc_loc_predicted_orbits_auto_download_config_s_type predicted_orbits_auto_download;
- case RPC_LOC_IOCTL_INJECT_UTC_TIME:
- rpc_loc_assist_data_time_s_type assistance_data_time;
- case RPC_LOC_IOCTL_INJECT_POSITION:
- rpc_loc_assist_data_pos_s_type assistance_data_position;
- case RPC_LOC_IOCTL_INFORM_SERVER_OPEN_STATUS:
- rpc_loc_server_open_status_s_type conn_open_status;
- case RPC_LOC_IOCTL_INFORM_SERVER_CLOSE_STATUS:
- rpc_loc_server_close_status_s_type conn_close_status;
- case RPC_LOC_IOCTL_SEND_WIPER_POSITION_REPORT:
- rpc_loc_wiper_position_report_s_type wiper_pos;
- case RPC_LOC_IOCTL_NOTIFY_WIPER_STATUS:
- rpc_loc_wiper_status_e_type wiper_status;
- case RPC_LOC_IOCTL_SET_ENGINE_LOCK:
- rpc_loc_lock_e_type engine_lock;
- case RPC_LOC_IOCTL_SET_SBAS_CONFIG:
- rpc_boolean sbas_mode;
- case RPC_LOC_IOCTL_SET_NMEA_TYPES:
- rpc_loc_nmea_sentence_type nmea_types;
- case RPC_LOC_IOCTL_SET_ON_DEMAND_LPM:
- rpc_boolean on_demand_lpm;
- case RPC_LOC_IOCTL_SET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_SET_CUSTOM_PDE_SERVER_ADDR:
- rpc_loc_server_info_s_type server_addr;
- case RPC_LOC_IOCTL_DELETE_ASSIST_DATA:
- rpc_loc_assist_data_delete_s_type assist_data_delete;
- case RPC_LOC_IOCTL_ACCESS_EFS_DATA:
- rpc_loc_efs_data_s_type efs_data;
- case RPC_LOC_IOCTL_ERROR_ESTIMATE_CONFIG:
- rpc_loc_error_estimate_config_e_type error_estimate_config;
- case RPC_LOC_IOCTL_SET_XTRA_T_SESSION_CONTROL:
- rpc_uint8 xtra_t_session_control;
- case RPC_LOC_IOCTL_SET_LBS_APN_PROFILE:
- case RPC_LOC_IOCTL_SET_XTRA_APN_PROFILE:
- rpc_loc_apn_profiles_type apn_profiles[6];
- case RPC_LOC_IOCTL_SET_DATA_ENABLE:
- rpc_boolean data_enable;
- case RPC_LOC_IOCTL_SET_SUPL_VERSION:
- rpc_uint32 supl_version;
- case RPC_LOC_IOCTL_INFORM_SERVER_MULTI_OPEN_STATUS:
- rpc_loc_server_multi_open_status_s_type multi_conn_open_status;
- case RPC_LOC_IOCTL_RESERVED_CMD:
- rpc_loc_reserved_payload_s_type reserved;
- default:
- void;
-};
-
-union rpc_loc_ioctl_callback_data_u_type switch (rpc_loc_ioctl_e_type disc) {
- case RPC_LOC_IOCTL_GET_API_VERSION:
- rpc_loc_api_version_s_type api_version;
- case RPC_LOC_IOCTL_GET_FIX_CRITERIA:
- rpc_loc_fix_criteria_s_type fix_criteria;
- case RPC_LOC_IOCTL_GET_ENGINE_LOCK:
- rpc_loc_lock_e_type engine_lock;
- case RPC_LOC_IOCTL_GET_SBAS_CONFIG:
- rpc_boolean sbas_mode;
- case RPC_LOC_IOCTL_GET_NMEA_TYPES:
- rpc_loc_nmea_sentence_type nmea_types;
- case RPC_LOC_IOCTL_GET_ON_DEMAND_LPM:
- rpc_boolean on_demand_lpm;
- case RPC_LOC_IOCTL_GET_CDMA_PDE_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CDMA_MPC_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_UMTS_SLP_SERVER_ADDR:
- case RPC_LOC_IOCTL_GET_CUSTOM_PDE_SERVER_ADDR:
- rpc_loc_server_info_s_type server_addr;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_SOURCE:
- rpc_loc_predicted_orbits_data_source_s_type predicted_orbits_data_source;
- case RPC_LOC_IOCTL_QUERY_PREDICTED_ORBITS_DATA_VALIDITY:
- rpc_loc_predicted_orbits_data_validity_report_s_type predicted_orbits_data_validity;
- case RPC_LOC_IOCTL_GET_XTRA_T_SESSION_CONTROL:
- rpc_uint8 xtra_t_session_control;
- case RPC_LOC_IOCTL_GET_LBS_APN_PROFILE:
- case RPC_LOC_IOCTL_GET_XTRA_APN_PROFILE:
- rpc_loc_apn_profiles_type apn_profiles[6];
- case RPC_LOC_IOCTL_GET_SUPL_VERSION:
- rpc_uint32 supl_version;
- default:
- void;
-};
-
-struct rpc_loc_ioctl_callback_s_type {
- rpc_loc_ioctl_e_type type;
- rpc_int32 status;
- rpc_loc_ioctl_callback_data_u_type data;
-};
-
-union rpc_loc_event_payload_u_type switch (unsigned hyper disc) {
- case RPC_LOC_EVENT_PARSED_POSITION_REPORT:
- rpc_loc_parsed_position_s_type parsed_location_report;
- case RPC_LOC_EVENT_SATELLITE_REPORT:
- rpc_loc_gnss_info_s_type gnss_report;
- case RPC_LOC_EVENT_NMEA_POSITION_REPORT:
- case RPC_LOC_EVENT_NMEA_1HZ_REPORT:
- rpc_loc_nmea_report_s_type nmea_report;
- case RPC_LOC_EVENT_NI_NOTIFY_VERIFY_REQUEST:
- rpc_loc_ni_event_s_type ni_request;
- case RPC_LOC_EVENT_ASSISTANCE_DATA_REQUEST:
- rpc_loc_assist_data_request_s_type assist_data_request;
- case RPC_LOC_EVENT_LOCATION_SERVER_REQUEST:
- rpc_loc_server_request_s_type loc_server_request;
- case RPC_LOC_EVENT_IOCTL_REPORT:
- rpc_loc_ioctl_callback_s_type ioctl_report;
- case RPC_LOC_EVENT_STATUS_REPORT:
- rpc_loc_status_event_s_type status_report;
- case RPC_LOC_EVENT_WPS_NEEDED_REQUEST:
- rpc_loc_qwip_request_s_type qwip_request;
- case RPC_LOC_EVENT_RESERVED:
- rpc_loc_reserved_payload_s_type reserved;
- default:
- void;
-};
-
diff --git a/msm8998/loc_api/libloc_api_50001/Android.mk b/msm8998/loc_api/libloc_api_50001/Android.mk
deleted file mode 100644
index 2c64d4b..0000000
--- a/msm8998/loc_api/libloc_api_50001/Android.mk
+++ /dev/null
@@ -1,116 +0,0 @@
-ifneq ($(BUILD_TINY_ANDROID),true)
-#Compile this library only for builds with the latest modem image
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := libloc_eng
-LOCAL_MODULE_OWNER := qcom
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SHARED_LIBRARIES := \
- libutils \
- libcutils \
- libdl \
- liblog \
- libloc_core \
- libgps.utils \
- libloc_pla
-
-LOCAL_SRC_FILES += \
- loc.cpp \
- loc_eng.cpp \
- loc_eng_agps.cpp \
- loc_eng_xtra.cpp \
- loc_eng_ni.cpp \
- loc_eng_log.cpp \
- loc_eng_nmea.cpp \
- LocEngAdapter.cpp
-
-LOCAL_SRC_FILES += \
- loc_eng_dmn_conn.cpp \
- loc_eng_dmn_conn_handler.cpp \
- loc_eng_dmn_conn_thread_helper.c \
- loc_eng_dmn_conn_glue_msg.c \
- loc_eng_dmn_conn_glue_pipe.c
-
-LOCAL_CFLAGS += \
- -fno-short-enums \
- -D_ANDROID_
-
-LOCAL_C_INCLUDES:= \
- $(TARGET_OUT_HEADERS)/gps.utils \
- $(TARGET_OUT_HEADERS)/libloc_core \
- $(LOCAL_PATH) \
- $(TARGET_OUT_HEADERS)/libflp \
- $(TARGET_OUT_HEADERS)/libloc_pla
-
-LOCAL_COPY_HEADERS_TO:= libloc_eng/
-LOCAL_COPY_HEADERS:= \
- LocEngAdapter.h \
- loc.h \
- loc_eng.h \
- loc_eng_xtra.h \
- loc_eng_ni.h \
- loc_eng_agps.h \
- loc_eng_msg.h \
- loc_eng_log.h
-
-LOCAL_PRELINK_MODULE := false
-
-include $(BUILD_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := gps.$(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE)
-LOCAL_MODULE_OWNER := qcom
-
-LOCAL_MODULE_TAGS := optional
-
-## Libs
-
-LOCAL_SHARED_LIBRARIES := \
- libutils \
- libcutils \
- liblog \
- libloc_eng \
- libloc_core \
- libgps.utils \
- libdl \
- libloc_pla
-
-ifneq ($(filter $(TARGET_DEVICE), apq8084 msm8960), false)
-endif
-
-LOCAL_SRC_FILES += \
- gps_interface.cpp \
- gps_converter.cpp \
- gps.c
-
-LOCAL_CFLAGS += \
- -fno-short-enums \
- -D_ANDROID_ \
-
-ifeq ($(TARGET_BUILD_VARIANT),user)
- LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
-endif
-
-ifeq ($(TARGET_USES_QCOM_BSP), true)
-LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP
-endif
-
-## Includes
-LOCAL_C_INCLUDES:= \
- $(TARGET_OUT_HEADERS)/gps.utils \
- $(TARGET_OUT_HEADERS)/libloc_core \
- $(TARGET_OUT_HEADERS)/libflp \
- $(TARGET_OUT_HEADERS)/libloc_pla
-
-LOCAL_PRELINK_MODULE := false
-LOCAL_MODULE_RELATIVE_PATH := hw
-
-include $(BUILD_SHARED_LIBRARY)
-
-endif # not BUILD_TINY_ANDROID
diff --git a/msm8998/loc_api/libloc_api_50001/LocEngAdapter.cpp b/msm8998/loc_api/libloc_api_50001/LocEngAdapter.cpp
deleted file mode 100644
index c312a24..0000000
--- a/msm8998/loc_api/libloc_api_50001/LocEngAdapter.cpp
+++ /dev/null
@@ -1,606 +0,0 @@
-/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_EngAdapter"
-
-#include <sys/stat.h>
-#include <errno.h>
-#include <ctype.h>
-#include <cutils/properties.h>
-#include <LocEngAdapter.h>
-#include "loc_eng_msg.h"
-#include "loc_log.h"
-
-#define CHIPSET_SERIAL_NUMBER_MAX_LEN 16
-#define USER_AGENT_MAX_LEN 512
-
-using namespace loc_core;
-
-LocInternalAdapter::LocInternalAdapter(LocEngAdapter* adapter) :
- LocAdapterBase(adapter->getMsgTask()),
- mLocEngAdapter(adapter)
-{
-}
-void LocInternalAdapter::setPositionModeInt(LocPosMode& posMode) {
- sendMsg(new LocEngPositionMode(mLocEngAdapter, posMode));
-}
-void LocInternalAdapter::startFixInt() {
- sendMsg(new LocEngStartFix(mLocEngAdapter));
-}
-void LocInternalAdapter::stopFixInt() {
- sendMsg(new LocEngStopFix(mLocEngAdapter));
-}
-void LocInternalAdapter::getZppInt() {
- sendMsg(new LocEngGetZpp(mLocEngAdapter));
-}
-
-LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
- void* owner, ContextBase* context,
- LocThread::tCreate tCreator) :
- LocAdapterBase(mask,
- //Get the AFW context if VzW context has not already been intialized in
- //loc_ext
- context == NULL?
- LocDualContext::getLocFgContext(tCreator,
- NULL,
- LocDualContext::mLocationHalName,
- false)
- :context),
- mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
- mUlp(new UlpProxyBase()), mNavigating(false),
- mSupportsAgpsRequests(false),
- mSupportsPositionInjection(false),
- mSupportsTimeInjection(false),
- mPowerVote(0)
-{
- memset(&mFixCriteria, 0, sizeof(mFixCriteria));
- mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
- clearGnssSvUsedListData();
- LOC_LOGD("LocEngAdapter created");
-}
-
-inline
-LocEngAdapter::~LocEngAdapter()
-{
- delete mInternalAdapter;
- LOC_LOGV("LocEngAdapter deleted");
-}
-
-void LocEngAdapter::setXtraUserAgent() {
- struct LocSetXtraUserAgent : public LocMsg {
- const ContextBase* const mContext;
- inline LocSetXtraUserAgent(ContextBase* context) :
- LocMsg(), mContext(context) {
- }
- virtual void proc() const {
- char release[PROPERTY_VALUE_MAX];
- char manufacture[PROPERTY_VALUE_MAX];
- char model[PROPERTY_VALUE_MAX];
- char board[PROPERTY_VALUE_MAX];
- char brand[PROPERTY_VALUE_MAX];
- char chipsetsn[CHIPSET_SERIAL_NUMBER_MAX_LEN];
- char userAgent[USER_AGENT_MAX_LEN];
- const char defVal[] = "-";
-
- property_get("ro.build.version.release", release, defVal);
- property_get("ro.product.manufacturer", manufacture, defVal);
- property_get("ro.product.model", model, defVal);
- property_get("ro.product.board", board, defVal);
- property_get("ro.product.brand", brand, defVal);
- getChipsetSerialNo(chipsetsn, sizeof(chipsetsn), defVal);
-
- encodeInPlace(release, PROPERTY_VALUE_MAX);
- encodeInPlace(manufacture, PROPERTY_VALUE_MAX);
- encodeInPlace(model, PROPERTY_VALUE_MAX);
- encodeInPlace(board, PROPERTY_VALUE_MAX);
- encodeInPlace(brand, PROPERTY_VALUE_MAX);
-
- snprintf(userAgent, sizeof(userAgent), "A/%s/%s/%s/%s/-/QCX3/s%u/-/%s/-/%s/-/-/-",
- release, manufacture, model, board,
- mContext->getIzatDevId(), chipsetsn, brand);
-
- for (int i = 0; i < sizeof(userAgent) && userAgent[i]; i++) {
- if (' ' == userAgent[i]) userAgent[i] = '#';
- }
-
- saveUserAgentString(userAgent, strlen(userAgent));
- LOC_LOGV("%s] UserAgent %s", __func__, userAgent);
- }
-
- void saveUserAgentString(const char* data, const int len) const {
- const char XTRA_FOLDER[] = "/data/misc/location/xtra";
- const char USER_AGENT_FILE[] = "/data/misc/location/xtra/useragent.txt";
-
- if (data == NULL || len < 1) {
- LOC_LOGE("%s:%d]: invalid input data = %p len = %d", __func__, __LINE__, data, len);
- return;
- }
-
- struct stat s;
- int err = stat(XTRA_FOLDER, &s);
- if (err < 0) {
- if (ENOENT == errno) {
- if (mkdir(XTRA_FOLDER, 0700) < 0) {
- LOC_LOGE("%s:%d]: make XTRA_FOLDER failed", __func__, __LINE__);
- return;
- }
- } else {
- LOC_LOGE("%s:%d]: XTRA_FOLDER invalid", __func__, __LINE__);
- return;
- }
- }
-
- FILE* file = fopen(USER_AGENT_FILE, "wt");
- if (file == NULL) {
- LOC_LOGE("%s:%d]: open USER_AGENT_FILE failed", __func__, __LINE__);
- return;
- }
-
- size_t written = fwrite(data, 1, len, file);
- fclose(file);
- file = NULL;
-
- // set file permission
- chmod(USER_AGENT_FILE, 0600);
-
- if (written != len) {
- LOC_LOGE("%s:%d]: write USER_AGENT_FILE failed", __func__, __LINE__);
- }
- }
-
- void getChipsetSerialNo(char buf[], int buflen, const char def[]) const {
- const char SOC_SERIAL_NUMBER[] = "/sys/devices/soc0/serial_number";
-
- FILE* file = fopen(SOC_SERIAL_NUMBER, "rt");
- if (file == NULL) {
- // use default upon unreadable file
- strlcpy(buf, def, buflen);
-
- } else {
- size_t size = fread(buf, 1, buflen - 1, file);
- if (size == 0) {
- // use default upon empty file
- strlcpy(buf, def, buflen);
-
- } else {
- buf[size] = '\0';
- }
-
- fclose(file);
-
- // remove trailing spaces
- size_t len = strlen(buf);
- while (--len >= 0 && isspace(buf[len])) {
- buf[len] = '\0';
- }
- }
-
- return;
- }
-
- /**
- * encode the given string value such that all separator characters ('/','+','|','%')
- * in the string are repaced by their corresponding encodings (%2F","%2B","%7C", "%25")
- */
- static void encodeInPlace(char value[], const int size) {
- char buffer[size];
-
- struct ENCODE {
- const char ch;
- const char *code;
- };
-
- const ENCODE encodings[] = { {'/', "%2F"}, {'+', "%2B"}, {'|', "%7C",}, {'%', "%25"} };
- const int nencodings = (int)sizeof(encodings) / sizeof(encodings[0]);
-
- int inpos = 0, outpos = 0;
- while(value[inpos] != '\0' && outpos < size - 1) {
- // check if escaped character
- int escchar = 0;
- while(escchar < nencodings && encodings[escchar].ch != value[inpos]) {
- escchar++;
- }
-
- if (escchar == nencodings) {
- // non escaped character
- buffer[outpos++] = value[inpos++];
- continue;
- }
-
- // escaped character
- int codepos = 0;
- #define NUM_CHARS_IN_CODE 3
-
- if (outpos + NUM_CHARS_IN_CODE >= size) {
- // skip last character if there is insufficient space
- break;
- }
-
- while(outpos < size - 1 && codepos < NUM_CHARS_IN_CODE) {
- buffer[outpos++] = encodings[escchar].code[codepos++];
- }
- inpos++;
- }
-
- // copy to ouput
- value[outpos] = '\0';
- while(--outpos >= 0) {
- value[outpos] = buffer[outpos];
- }
- }
- };
-
- sendMsg(new LocSetXtraUserAgent(mContext));
-}
-
-void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
- struct LocSetUlpProxy : public LocMsg {
- LocAdapterBase* mAdapter;
- UlpProxyBase* mUlp;
- inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
- LocMsg(), mAdapter(adapter), mUlp(ulp) {
- }
- virtual void proc() const {
- LOC_LOGV("%s] ulp %p adapter %p", __func__,
- mUlp, mAdapter);
- mAdapter->setUlpProxy(mUlp);
- }
- };
-
- sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
-}
-
-void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp)
-{
- if (ulp == mUlp) {
- //This takes care of the case when double initalization happens
- //and we get the same object back for UlpProxyBase . Do nothing
- return;
- }
-
- LOC_LOGV("%s] %p", __func__, ulp);
- if (NULL == ulp) {
- LOC_LOGE("%s:%d]: ulp pointer is NULL", __func__, __LINE__);
- ulp = new UlpProxyBase();
- }
-
- if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) {
- // need to send this mode and start msg to ULP
- ulp->sendFixMode(mUlp->mPosMode);
- }
-
- if(mUlp->mFixSet) {
- ulp->sendStartFix();
- }
-
- delete mUlp;
- mUlp = ulp;
-}
-
-int LocEngAdapter::setGpsLockMsg(LOC_GPS_LOCK_MASK lockMask)
-{
- struct LocEngAdapterGpsLock : public LocMsg {
- LocEngAdapter* mAdapter;
- LOC_GPS_LOCK_MASK mLockMask;
- inline LocEngAdapterGpsLock(LocEngAdapter* adapter, LOC_GPS_LOCK_MASK lockMask) :
- LocMsg(), mAdapter(adapter), mLockMask(lockMask)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setGpsLock(mLockMask);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngAdapterGpsLock - mLockMask: %x", mLockMask);
- }
- inline virtual void log() const {
- locallog();
- }
- };
- sendMsg(new LocEngAdapterGpsLock(this, lockMask));
- return 0;
-}
-
-void LocEngAdapter::requestPowerVote()
-{
- if (getPowerVoteRight()) {
- /* Power voting without engine lock:
- * 101: vote down, 102-104 - vote up
- * These codes are used not to confuse with actual engine lock
- * functionality, that can't be used in SSR scenario, as it
- * conflicts with initialization sequence.
- */
- bool powerUp = getPowerVote();
- LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d", (int)powerUp);
- setGpsLock(powerUp ? 103 : 101);
- }
-}
-
-void LocInternalAdapter::reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask)
-{
- sendMsg(new LocEngReportPosition(mLocEngAdapter,
- location,
- locationExtended,
- locationExt,
- status,
- loc_technology_mask));
-}
-
-
-void LocEngAdapter::reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask)
-{
- if (! mUlp->reportPosition(location,
- locationExtended,
- locationExt,
- status,
- loc_technology_mask )) {
- mInternalAdapter->reportPosition(location,
- locationExtended,
- locationExt,
- status,
- loc_technology_mask);
- }
-}
-
-void LocInternalAdapter::reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt){
- sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus,
- locationExtended, svExt));
-}
-
-void LocEngAdapter::reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt)
-{
-
- // We want to send SV info to ULP to help it in determining GNSS
- // signal strength ULP will forward the SV reports to HAL without
- // any modifications
- if (! mUlp->reportSv(svStatus, locationExtended, svExt)) {
- mInternalAdapter->reportSv(svStatus, locationExtended, svExt);
- }
-}
-
-
-void LocEngAdapter::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
-{
- // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
- if (! mUlp->reportSvMeasurement(svMeasurementSet)) {
- //Send to Internal Adapter later if needed by LA
- }
-}
-
-void LocEngAdapter::reportSvPolynomial(GnssSvPolynomial &svPolynomial)
-{
- // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
- if (! mUlp->reportSvPolynomial(svPolynomial)) {
- //Send to Internal Adapter later if needed by LA
- }
-}
-
-void LocEngAdapter::setInSession(bool inSession)
-{
- mNavigating = inSession;
- mLocApi->setInSession(inSession);
- if (!mNavigating) {
- mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
- }
-}
-
-void LocInternalAdapter::reportStatus(LocGpsStatusValue status)
-{
- sendMsg(new LocEngReportStatus(mLocEngAdapter, status));
-}
-
-void LocEngAdapter::reportStatus(LocGpsStatusValue status)
-{
- if (!mUlp->reportStatus(status)) {
- mInternalAdapter->reportStatus(status);
- }
-}
-
-void LocInternalAdapter::reportNmea(const char* nmea, int length)
-{
- sendMsg(new LocEngReportNmea(mLocEngAdapter->getOwner(), nmea, length));
-}
-
-inline void LocEngAdapter::reportNmea(const char* nmea, int length)
-{
- if (!mUlp->reportNmea(nmea, length)) {
- //Report it to HAL
- mInternalAdapter->reportNmea(nmea, length);
- }
-}
-
-inline
-bool LocEngAdapter::reportXtraServer(const char* url1,
- const char* url2,
- const char* url3,
- const int maxlength)
-{
- if (mSupportsAgpsRequests) {
- sendMsg(new LocEngReportXtraServer(mOwner, url1,
- url2, url3, maxlength));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::requestATL(int connHandle, LocAGpsType agps_type)
-{
- if (mSupportsAgpsRequests) {
- sendMsg(new LocEngRequestATL(mOwner,
- connHandle, agps_type));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::releaseATL(int connHandle)
-{
- if (mSupportsAgpsRequests) {
- sendMsg(new LocEngReleaseATL(mOwner, connHandle));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::requestXtraData()
-{
- if (mSupportsAgpsRequests) {
- sendMsg(new LocEngRequestXtra(mOwner));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::requestTime()
-{
- if (mSupportsAgpsRequests) {
- sendMsg(new LocEngRequestTime(mOwner));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::requestNiNotify(LocGpsNiNotification ¬if, const void* data)
-{
- if (mSupportsAgpsRequests) {
- notif.size = sizeof(notif);
- notif.timeout = LOC_NI_NO_RESPONSE_TIME;
-
- sendMsg(new LocEngRequestNi(mOwner, notif, data));
- }
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::requestSuplES(int connHandle)
-{
- if (mSupportsAgpsRequests)
- sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::reportDataCallOpened()
-{
- if(mSupportsAgpsRequests)
- sendMsg(new LocEngSuplEsOpened(mOwner));
- return mSupportsAgpsRequests;
-}
-
-inline
-bool LocEngAdapter::reportDataCallClosed()
-{
- if(mSupportsAgpsRequests)
- sendMsg(new LocEngSuplEsClosed(mOwner));
- return mSupportsAgpsRequests;
-}
-
-inline
-void LocEngAdapter::handleEngineDownEvent()
-{
- sendMsg(new LocEngDown(mOwner));
-}
-
-inline
-void LocEngAdapter::handleEngineUpEvent()
-{
- sendMsg(new LocEngUp(mOwner));
-}
-
-enum loc_api_adapter_err LocEngAdapter::setTime(LocGpsUtcTime time,
- int64_t timeReference,
- int uncertainty)
-{
- loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS;
-
- LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d",
- __func__, __LINE__, mSupportsTimeInjection);
-
- if (mSupportsTimeInjection) {
- LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__);
- result = mLocApi->setTime(time, timeReference, uncertainty);
- }
-
- return result;
-}
-
-enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
-{
- enum loc_api_adapter_err ret;
- ENTRY_LOG();
- enum xtra_version_check eCheck;
- switch (check) {
- case 0:
- eCheck = DISABLED;
- break;
- case 1:
- eCheck = AUTO;
- break;
- case 2:
- eCheck = XTRA2;
- break;
- case 3:
- eCheck = XTRA3;
- break;
- default:
- eCheck = DISABLED;
- }
- ret = mLocApi->setXtraVersionCheck(eCheck);
- EXIT_LOG(%d, ret);
- return ret;
-}
-
-void LocEngAdapter::reportGnssMeasurementData(LocGnssData &gnssMeasurementData)
-{
- sendMsg(new LocEngReportGnssMeasurement(mOwner,
- gnssMeasurementData));
-}
-
-/*
- Set Gnss Constellation Config
- */
-bool LocEngAdapter::gnssConstellationConfig()
-{
- LOC_LOGD("entering %s", __func__);
- bool result = false;
- result = mLocApi->gnssConstellationConfig();
- return result;
-}
diff --git a/msm8998/loc_api/libloc_api_50001/LocEngAdapter.h b/msm8998/loc_api/libloc_api_50001/LocEngAdapter.h
deleted file mode 100644
index e341651..0000000
--- a/msm8998/loc_api/libloc_api_50001/LocEngAdapter.h
+++ /dev/null
@@ -1,380 +0,0 @@
-/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_API_ENG_ADAPTER_H
-#define LOC_API_ENG_ADAPTER_H
-
-#include <ctype.h>
-#include <loc.h>
-#include <loc_eng_log.h>
-#include <LocAdapterBase.h>
-#include <LocDualContext.h>
-#include <UlpProxyBase.h>
-#include <platform_lib_includes.h>
-
-#define MAX_URL_LEN 256
-
-using namespace loc_core;
-
-class LocEngAdapter;
-
-class LocInternalAdapter : public LocAdapterBase {
- LocEngAdapter* mLocEngAdapter;
-public:
- LocInternalAdapter(LocEngAdapter* adapter);
-
- virtual void reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask);
- virtual void reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt);
- virtual void reportStatus(LocGpsStatusValue status);
- virtual void setPositionModeInt(LocPosMode& posMode);
- virtual void startFixInt();
- virtual void stopFixInt();
- virtual void getZppInt();
- virtual void setUlpProxy(UlpProxyBase* ulp);
- virtual void reportNmea(const char* nmea, int length);
-};
-
-typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp);
-
-class LocEngAdapter : public LocAdapterBase {
- void* mOwner;
- LocInternalAdapter* mInternalAdapter;
- UlpProxyBase* mUlp;
- LocPosMode mFixCriteria;
- bool mNavigating;
- // mPowerVote is encoded as
- // mPowerVote & 0x20 -- powerVoteRight
- // mPowerVote & 0x10 -- power On / Off
- unsigned int mPowerVote;
- static const unsigned int POWER_VOTE_RIGHT = 0x20;
- static const unsigned int POWER_VOTE_VALUE = 0x10;
- /** Gnss sv used in position data */
- GnssSvUsedInPosition mGnssSvIdUsedInPosition;
- bool mGnssSvIdUsedInPosAvail;
-public:
- bool mSupportsAgpsRequests;
- bool mSupportsPositionInjection;
- bool mSupportsTimeInjection;
- LocGnssSystemInfo mGnssInfo;
-
- LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
- void* owner, ContextBase* context,
- LocThread::tCreate tCreator);
- virtual ~LocEngAdapter();
-
- virtual void setUlpProxy(UlpProxyBase* ulp);
- void setXtraUserAgent();
- inline void requestUlp(unsigned long capabilities) {
- mContext->requestUlp(mInternalAdapter, capabilities);
- }
- inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; }
- inline UlpProxyBase* getUlpProxy() { return mUlp; }
- inline void* getOwner() { return mOwner; }
- inline bool hasAgpsExtendedCapabilities() {
- return mContext->hasAgpsExtendedCapabilities();
- }
- inline bool hasCPIExtendedCapabilities() {
- return mContext->hasCPIExtendedCapabilities();
- }
- inline bool hasNativeXtraClient() {
- return mContext->hasNativeXtraClient();
- }
- inline const MsgTask* getMsgTask() { return mMsgTask; }
-
- inline void clearGnssSvUsedListData() {
- mGnssSvIdUsedInPosAvail = false;
- memset(&mGnssSvIdUsedInPosition, 0, sizeof (GnssSvUsedInPosition));
- }
-
- inline void setGnssSvUsedListData(GnssSvUsedInPosition gnssSvUsedIds) {
- mGnssSvIdUsedInPosAvail = true;
- memcpy(&mGnssSvIdUsedInPosition, &gnssSvUsedIds,
- sizeof(GnssSvUsedInPosition));
- }
-
- inline GnssSvUsedInPosition getGnssSvUsedListData() {
- return mGnssSvIdUsedInPosition;
- }
-
- inline bool isGnssSvIdUsedInPosAvail() {
- return mGnssSvIdUsedInPosAvail;
- }
-
- inline enum loc_api_adapter_err
- startFix()
- {
- return mLocApi->startFix(mFixCriteria);
- }
- inline enum loc_api_adapter_err
- stopFix()
- {
- return mLocApi->stopFix();
- }
- inline enum loc_api_adapter_err
- deleteAidingData(LocGpsAidingData f)
- {
- return mLocApi->deleteAidingData(f);
- }
- inline enum loc_api_adapter_err
- enableData(int enable)
- {
- return mLocApi->enableData(enable);
- }
- inline enum loc_api_adapter_err
- setAPN(char* apn, int len)
- {
- return mLocApi->setAPN(apn, len);
- }
- inline enum loc_api_adapter_err
- injectPosition(double latitude, double longitude, float accuracy)
- {
- return mLocApi->injectPosition(latitude, longitude, accuracy);
- }
- inline enum loc_api_adapter_err
- setXtraData(char* data, int length)
- {
- return mLocApi->setXtraData(data, length);
- }
- inline enum loc_api_adapter_err
- requestXtraServer()
- {
- return mLocApi->requestXtraServer();
- }
- inline enum loc_api_adapter_err
- atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, LocAGpsType agpsType)
- {
- return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType);
- }
- inline enum loc_api_adapter_err
- atlCloseStatus(int handle, int is_succ)
- {
- return mLocApi->atlCloseStatus(handle, is_succ);
- }
- inline enum loc_api_adapter_err
- setPositionMode(const LocPosMode *posMode)
- {
- if (NULL != posMode) {
- mFixCriteria = *posMode;
- }
- return mLocApi->setPositionMode(mFixCriteria);
- }
- inline enum loc_api_adapter_err
- setServer(const char* url, int len)
- {
- return mLocApi->setServer(url, len);
- }
- inline enum loc_api_adapter_err
- setServer(unsigned int ip, int port,
- LocServerType type)
- {
- return mLocApi->setServer(ip, port, type);
- }
- inline enum loc_api_adapter_err
- informNiResponse(LocGpsUserResponseType userResponse, const void* passThroughData)
- {
- return mLocApi->informNiResponse(userResponse, passThroughData);
- }
- inline enum loc_api_adapter_err
- setSUPLVersion(uint32_t version)
- {
- return mLocApi->setSUPLVersion(version);
- }
- inline enum loc_api_adapter_err
- setNMEATypes (uint32_t typesMask)
- {
- return mLocApi->setNMEATypes(typesMask);
- }
- inline enum loc_api_adapter_err
- setLPPConfig(uint32_t profile)
- {
- return mLocApi->setLPPConfig(profile);
- }
- inline enum loc_api_adapter_err
- setSensorControlConfig(int sensorUsage, int sensorProvider)
- {
- return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider);
- }
- inline enum loc_api_adapter_err
- setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk,
- bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk,
- bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk,
- bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk,
- bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk)
- {
- return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk,
- accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk,
- angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk,
- rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk,
- velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk);
- }
- inline virtual enum loc_api_adapter_err
- setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec,
- int gyroSamplesPerBatch, int gyroBatchesPerSec,
- int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
- int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig)
- {
- return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec,
- gyroSamplesPerBatch, gyroBatchesPerSec,
- accelSamplesPerBatchHigh, accelBatchesPerSecHigh,
- gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh,
- algorithmConfig);
- }
- inline virtual enum loc_api_adapter_err
- setAGLONASSProtocol(unsigned long aGlonassProtocol)
- {
- return mLocApi->setAGLONASSProtocol(aGlonassProtocol);
- }
- inline virtual enum loc_api_adapter_err
- setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP)
- {
- return mLocApi->setLPPeProtocol(lppeCP, lppeUP);
- }
- inline virtual int initDataServiceClient(bool isDueToSsr)
- {
- return mLocApi->initDataServiceClient(isDueToSsr);
- }
- inline virtual int openAndStartDataCall()
- {
- return mLocApi->openAndStartDataCall();
- }
- inline virtual void stopDataCall()
- {
- mLocApi->stopDataCall();
- }
- inline virtual void closeDataCall()
- {
- mLocApi->closeDataCall();
- }
- inline virtual void releaseDataServiceClient()
- {
- mLocApi->releaseDataServiceClient();
- }
- inline enum loc_api_adapter_err
- getZpp(LocGpsLocation &zppLoc, LocPosTechMask &tech_mask)
- {
- return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask);
- }
- enum loc_api_adapter_err setTime(LocGpsUtcTime time,
- int64_t timeReference,
- int uncertainty);
- enum loc_api_adapter_err setXtraVersionCheck(int check);
- inline virtual void installAGpsCert(const LocDerEncodedCertificate* pData,
- size_t length,
- uint32_t slotBitMask)
- {
- mLocApi->installAGpsCert(pData, length, slotBitMask);
- }
- virtual void handleEngineDownEvent();
- virtual void handleEngineUpEvent();
- virtual void reportPosition(UlpLocation &location,
- GpsLocationExtended &locationExtended,
- void* locationExt,
- enum loc_sess_status status,
- LocPosTechMask loc_technology_mask);
- virtual void reportSv(LocGnssSvStatus &svStatus,
- GpsLocationExtended &locationExtended,
- void* svExt);
- virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet);
- virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
- virtual void reportStatus(LocGpsStatusValue status);
- virtual void reportNmea(const char* nmea, int length);
- virtual bool reportXtraServer(const char* url1, const char* url2,
- const char* url3, const int maxlength);
- virtual bool requestXtraData();
- virtual bool requestTime();
- virtual bool requestATL(int connHandle, LocAGpsType agps_type);
- virtual bool releaseATL(int connHandle);
- virtual bool requestNiNotify(LocGpsNiNotification ¬ify, const void* data);
- virtual bool requestSuplES(int connHandle);
- virtual bool reportDataCallOpened();
- virtual bool reportDataCallClosed();
- virtual void reportGnssMeasurementData(LocGnssData &gnssMeasurementData);
-
- inline const LocPosMode& getPositionMode() const
- {return mFixCriteria;}
- inline virtual bool isInSession()
- { return mNavigating; }
- void setInSession(bool inSession);
-
- // Permit/prohibit power voting
- inline void setPowerVoteRight(bool powerVoteRight) {
- mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) :
- (mPowerVote & ~POWER_VOTE_RIGHT);
- }
- inline bool getPowerVoteRight() const {
- return (mPowerVote & POWER_VOTE_RIGHT) != 0 ;
- }
- // Set the power voting up/down and do actual operation if permitted
- inline void setPowerVote(bool powerOn) {
- mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) :
- (mPowerVote & ~POWER_VOTE_VALUE);
- requestPowerVote();
- mContext->modemPowerVote(powerOn);
- }
- inline bool getPowerVote() const {
- return (mPowerVote & POWER_VOTE_VALUE) != 0 ;
- }
- // Do power voting according to last settings if permitted
- void requestPowerVote();
-
- /*Values for lock
- 1 = Do not lock any position sessions
- 2 = Lock MI position sessions
- 3 = Lock MT position sessions
- 4 = Lock all position sessions
- */
- inline int setGpsLock(LOC_GPS_LOCK_MASK lock)
- {
- return mLocApi->setGpsLock(lock);
- }
-
- int setGpsLockMsg(LOC_GPS_LOCK_MASK lock);
-
- /*
- Returns
- Current value of GPS lock on success
- -1 on failure
- */
- inline int getGpsLock()
- {
- return mLocApi->getGpsLock();
- }
-
- /*
- Set Gnss Constellation Config
- */
- bool gnssConstellationConfig();
-};
-
-#endif //LOC_API_ENG_ADAPTER_H
diff --git a/msm8998/loc_api/libloc_api_50001/Makefile.am b/msm8998/loc_api/libloc_api_50001/Makefile.am
deleted file mode 100644
index 8fe5fc1..0000000
--- a/msm8998/loc_api/libloc_api_50001/Makefile.am
+++ /dev/null
@@ -1,62 +0,0 @@
-AM_CFLAGS = \
- -I../../utils \
- -I../../platform_lib_abstractions \
- -I$(WORKSPACE)/gps-noship/flp \
- -fno-short-enums \
- -D__func__=__PRETTY_FUNCTION__ \
- -DFEATURE_GNSS_BIT_API
-
-libloc_adapter_so_la_SOURCES = loc_eng_log.cpp LocEngAdapter.cpp
-
-if USE_GLIB
-libloc_adapter_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_adapter_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_adapter_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_adapter_so_la_CFLAGS = $(AM_CFLAGS)
-libloc_adapter_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_adapter_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-libloc_adapter_so_la_LIBADD = -lstdc++ -lcutils ../../utils/libgps_utils_so.la
-
-
-libloc_eng_so_la_SOURCES = \
- loc.cpp \
- loc_eng.cpp \
- loc_eng_agps.cpp \
- loc_eng_xtra.cpp \
- loc_eng_ni.cpp \
- loc_eng_log.cpp \
- loc_eng_dmn_conn.cpp \
- loc_eng_dmn_conn_handler.cpp \
- loc_eng_dmn_conn_thread_helper.c \
- loc_eng_dmn_conn_glue_msg.c \
- loc_eng_dmn_conn_glue_pipe.c
-
-
-if USE_GLIB
-libloc_eng_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_eng_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-libloc_eng_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-libloc_eng_so_la_CFLAGS = $(AM_CFLAGS)
-libloc_eng_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-libloc_eng_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-
-libloc_eng_so_la_LIBADD = -lstdc++ -lcutils -ldl ../../utils/libgps_utils_so.la libloc_adapter_so.la
-
-library_include_HEADERS = \
- LocEngAdapter.h \
- loc.h \
- loc_eng.h \
- loc_eng_xtra.h \
- loc_eng_ni.h \
- loc_eng_agps.h \
- loc_eng_msg.h \
- loc_eng_log.h
-
-library_includedir = $(pkgincludedir)/libloc_api_50001
-
-#Create and Install libraries
-lib_LTLIBRARIES = libloc_adapter_so.la libloc_eng_so.la
diff --git a/msm8998/loc_api/libloc_api_50001/gps.c b/msm8998/loc_api/libloc_api_50001/gps.c
deleted file mode 100644
index 29f20f4..0000000
--- a/msm8998/loc_api/libloc_api_50001/gps.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Copyright (c) 2011,2015 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <hardware/gps.h>
-
-#include <stdlib.h>
-#include <string.h>
-
-extern const GpsInterface* get_gps_interface();
-
-const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev)
-{
- return get_gps_interface();
-}
-
-static int open_gps(const struct hw_module_t* module, char const* name,
- struct hw_device_t** device)
-{
- struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t));
-
- if(dev == NULL)
- return -1;
-
- memset(dev, 0, sizeof(*dev));
-
- dev->common.tag = HARDWARE_DEVICE_TAG;
- dev->common.version = 0;
- dev->common.module = (struct hw_module_t*)module;
- dev->get_gps_interface = gps__get_gps_interface;
-
- *device = (struct hw_device_t*)dev;
- return 0;
-}
-
-static struct hw_module_methods_t gps_module_methods = {
- .open = open_gps
-};
-
-struct hw_module_t HAL_MODULE_INFO_SYM = {
- .tag = HARDWARE_MODULE_TAG,
- .module_api_version = 1,
- .hal_api_version = 0,
- .id = GPS_HARDWARE_MODULE_ID,
- .name = "loc_api GPS Module",
- .author = "Qualcomm USA, Inc.",
- .methods = &gps_module_methods,
-};
diff --git a/msm8998/loc_api/libloc_api_50001/gps_converter.cpp b/msm8998/loc_api/libloc_api_50001/gps_converter.cpp
deleted file mode 100644
index 1ca23cf..0000000
--- a/msm8998/loc_api/libloc_api_50001/gps_converter.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-/* Copyright (c) 2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <gps_converter.h>
-
-void A2Q_DerEncodedCertificate(const DerEncodedCertificate& in, LocDerEncodedCertificate& out) {
- memset(&out, 0, sizeof(LocDerEncodedCertificate));
- out.length = in.length;
- out.data = in.data;
-}
-
-void Q2A_GpsLocation(const LocGpsLocation& in, GpsLocation& out) {
- memset(&out, 0, sizeof(GpsLocation));
- out.size = sizeof(GpsLocation);
- out.flags = (LocGpsLocationFlags)in.flags;
- out.latitude = in.latitude;
- out.longitude = in.longitude;
- out.altitude = in.altitude;
- out.speed = in.speed;
- out.bearing = in.bearing;
- out.accuracy = in.accuracy;
- out.timestamp = Q2A_GpsUtcTime(in.timestamp);
-}
-
-void Q2A_GpsSvInfo(const LocGpsSvInfo& in, GpsSvInfo& out) {
- memset(&out, 0, sizeof(GpsSvInfo));
- out.size = sizeof(GpsSvInfo);
- out.prn = in.prn;
- out.snr = in.snr;
- out.elevation = in.elevation;
- out.azimuth = in.azimuth;
-}
-
-void Q2A_GpsSvStatus(const LocGpsSvStatus& in, GpsSvStatus& out) {
- memset(&out, 0, sizeof(GpsSvStatus));
- out.size = sizeof(GpsSvStatus);
- out.num_svs = in.num_svs;
- int len = LOC_GPS_MAX_SVS < GPS_MAX_SVS ? LOC_GPS_MAX_SVS : GPS_MAX_SVS;
- for (int i = 0; i < len; i++) {
- Q2A_GpsSvInfo(in.sv_list[i], out.sv_list[i]);
- }
- out.ephemeris_mask = in.ephemeris_mask;
- out.almanac_mask = in.almanac_mask;
- out.used_in_fix_mask = in.used_in_fix_mask;
-}
-
-void Q2A_GnssSvInfo(const LocGnssSvInfo& in, GnssSvInfo& out) {
- memset(&out, 0, sizeof(GnssSvInfo));
- out.size = sizeof(GnssSvInfo);
- out.svid = in.svid;
- out.constellation = (GnssConstellationType)in.constellation;
- out.c_n0_dbhz = in.c_n0_dbhz;
- out.elevation = in.elevation;
- out.azimuth = in.azimuth;
- out.flags = (GnssSvFlags)in.flags;
-}
-
-void Q2A_GnssSvStatus(const LocGnssSvStatus& in, GnssSvStatus& out) {
- memset(&out, 0, sizeof(GnssSvStatus));
- out.size = sizeof(GnssSvStatus);
- out.num_svs = in.num_svs;
- int len = LOC_GNSS_MAX_SVS < GNSS_MAX_SVS ? LOC_GNSS_MAX_SVS : GNSS_MAX_SVS;
- for (int i = 0; i < len; i++) {
- Q2A_GnssSvInfo(in.gnss_sv_list[i], out.gnss_sv_list[i]);
- }
-}
-
-void Q2A_GpsNiNotification(const LocGpsNiNotification& in, GpsNiNotification& out) {
- memset(&out, 0, sizeof(GpsNiNotification));
- out.size = sizeof(GpsNiNotification);
- out.notification_id = in.notification_id;
- out.ni_type = (GpsNiType)in.ni_type;
- out.notify_flags = (GpsNiNotifyFlags)in.notify_flags;
- out.timeout = in.timeout;
- out.default_response = (GpsUserResponseType)in.default_response;
- int len = LOC_GPS_NI_SHORT_STRING_MAXLEN < GPS_NI_SHORT_STRING_MAXLEN
- ? LOC_GPS_NI_SHORT_STRING_MAXLEN : GPS_NI_SHORT_STRING_MAXLEN;
- for (int i = 0; i < len; i++) {
- out.requestor_id[i] = in.requestor_id[i];
- }
- len = LOC_GPS_NI_LONG_STRING_MAXLEN < GPS_NI_LONG_STRING_MAXLEN
- ? LOC_GPS_NI_LONG_STRING_MAXLEN : GPS_NI_LONG_STRING_MAXLEN;
- for (int i = 0; i < len; i++) {
- out.text[i] = in.text[i];
- }
- out.requestor_id_encoding = (GpsNiEncodingType)in.requestor_id_encoding;
- out.text_encoding = (GpsNiEncodingType)in.text_encoding;
- len = LOC_GPS_NI_LONG_STRING_MAXLEN < GPS_NI_LONG_STRING_MAXLEN
- ? LOC_GPS_NI_LONG_STRING_MAXLEN : GPS_NI_LONG_STRING_MAXLEN;
- for (int i = 0; i < len; i++) {
- out.extras[i] = in.extras[i];
- }
-}
-
-void Q2A_GpsStatus(const LocGpsStatus& in, GpsStatus& out) {
- memset(&out, 0, sizeof(GpsStatus));
- out.size = sizeof(GpsStatus);
- out.status = (GpsStatusValue)in.status;
-}
-
-void Q2A_GnssSystemInfo(const LocGnssSystemInfo& in, GnssSystemInfo& out) {
- memset(&out, 0, sizeof(GnssSystemInfo));
- out.size = sizeof(GnssSystemInfo);
- out.year_of_hw = in.year_of_hw;
-}
-
-void Q2A_AGpsStatus(const LocAGpsStatus& in, AGpsStatus& out) {
- memset(&out, 0, sizeof(AGpsStatus));
- out.size = sizeof(AGpsStatus);
- out.type = (AGpsType)in.type;
- out.status = (AGpsStatusValue)in.status;
- out.ipaddr = in.ipaddr;
- memcpy(&out.addr, &in.addr, sizeof(sockaddr_storage));
-}
-
-void Q2A_GpsMeasurement(const LocGpsMeasurement& in, GpsMeasurement& out) {
- memset(&out, 0, sizeof(GpsMeasurement));
- out.size = sizeof(GpsMeasurement);
- out.flags = (GpsMeasurementFlags)in.flags;
- out.prn = in.prn;
- out.time_offset_ns = in.time_offset_ns;
- out.state = (GpsMeasurementState)in.state;
- out.received_gps_tow_ns = in.received_gps_tow_ns;
- out.received_gps_tow_uncertainty_ns = in.received_gps_tow_uncertainty_ns;
- out.c_n0_dbhz = in.c_n0_dbhz;
- out.pseudorange_rate_mps = in.pseudorange_rate_mps;
- out.pseudorange_rate_uncertainty_mps = in.pseudorange_rate_uncertainty_mps;
- out.accumulated_delta_range_state = (GpsAccumulatedDeltaRangeState)in.accumulated_delta_range_state;
- out.accumulated_delta_range_m = in.accumulated_delta_range_m;
- out.accumulated_delta_range_uncertainty_m = in.accumulated_delta_range_uncertainty_m;
- out.pseudorange_m = in.pseudorange_m;
- out.pseudorange_uncertainty_m = in.pseudorange_uncertainty_m;
- out.code_phase_chips = in.code_phase_chips;
- out.code_phase_uncertainty_chips = in.code_phase_uncertainty_chips;
- out.carrier_frequency_hz = in.carrier_frequency_hz;
- out.carrier_cycles = in.carrier_cycles;
- out.carrier_phase = in.carrier_phase;
- out.carrier_phase_uncertainty = in.carrier_phase_uncertainty;
- out.loss_of_lock = (GpsLossOfLock)in.loss_of_lock;
- out.bit_number = in.bit_number;
- out.time_from_last_bit_ms = in.time_from_last_bit_ms;
- out.doppler_shift_hz = in.doppler_shift_hz;
- out.doppler_shift_uncertainty_hz = in.doppler_shift_uncertainty_hz;
- out.multipath_indicator = (GpsMultipathIndicator)in.multipath_indicator;
- out.snr_db = in.snr_db;
- out.elevation_deg = in.elevation_deg;
- out.elevation_uncertainty_deg = in.elevation_uncertainty_deg;
- out.azimuth_deg = in.azimuth_deg;
- out.azimuth_uncertainty_deg = in.azimuth_uncertainty_deg;
- out.used_in_fix = in.used_in_fix;
-}
-
-void Q2A_GpsClock(const LocGpsClock& in, GpsClock& out) {
- memset(&out, 0, sizeof(GpsClock));
- out.size = sizeof(GpsClock);
- out.flags = (GpsClockFlags)in.flags;
- out.leap_second = in.leap_second;
- out.type = (GpsClockType)in.type;
- out.time_ns = in.time_ns;
- out.time_uncertainty_ns = in.time_uncertainty_ns;
- out.full_bias_ns = in.full_bias_ns;
- out.bias_ns = in.bias_ns;
- out.bias_uncertainty_ns = in.bias_uncertainty_ns;
- out.drift_nsps = in.drift_nsps;
- out.drift_uncertainty_nsps = in.drift_uncertainty_nsps;
-}
-
-void Q2A_GpsData(const LocGpsData& in, GpsData& out) {
- memset(&out, 0, sizeof(GpsData));
- out.size = sizeof(GpsData);
- out.measurement_count = in.measurement_count;
- int len = LOC_GPS_MAX_MEASUREMENT < GPS_MAX_MEASUREMENT
- ? LOC_GPS_MAX_MEASUREMENT : GPS_MAX_MEASUREMENT;
- for (int i = 0; i < len; i++) {
- Q2A_GpsMeasurement(in.measurements[i], out.measurements[i]);
- }
- Q2A_GpsClock(in.clock, out.clock);
-}
-
-void Q2A_GnssMeasurement(const LocGnssMeasurement& in, GnssMeasurement& out) {
- memset(&out, 0, sizeof(GnssMeasurement));
- out.size = sizeof(GnssMeasurement);
- out.flags = (GpsMeasurementFlags)in.flags;
- out.svid = in.svid;
- out.constellation = (GnssConstellationType)in.constellation;
- out.time_offset_ns = in.time_offset_ns;
- out.state = (GnssMeasurementState)in.state;
- out.received_sv_time_in_ns = in.received_sv_time_in_ns;
- out.received_sv_time_uncertainty_in_ns = in.received_sv_time_uncertainty_in_ns;
- out.c_n0_dbhz = in.c_n0_dbhz;
- out.pseudorange_rate_mps = in.pseudorange_rate_mps;
- out.pseudorange_rate_uncertainty_mps = in.pseudorange_rate_uncertainty_mps;
- out.accumulated_delta_range_state = (GnssAccumulatedDeltaRangeState)in.accumulated_delta_range_state;
- out.accumulated_delta_range_m = in.accumulated_delta_range_m;
- out.accumulated_delta_range_uncertainty_m = in.accumulated_delta_range_uncertainty_m;
- out.carrier_frequency_hz = in.carrier_frequency_hz;
- out.carrier_cycles = in.carrier_cycles;
- out.carrier_phase = in.carrier_phase;
- out.carrier_phase_uncertainty = in.carrier_phase_uncertainty;
- out.multipath_indicator = (GnssMultipathIndicator)in.multipath_indicator;
- out.snr_db = in.snr_db;
-}
-
-void Q2A_GnssClock(const LocGnssClock& in, GnssClock& out) {
- memset(&out, 0, sizeof(GnssClock));
- out.size = sizeof(GnssClock);
- out.flags = (GnssClockFlags)in.flags;
- out.leap_second = in.leap_second;
- out.time_ns = in.time_ns;
- out.time_uncertainty_ns = in.time_uncertainty_ns;
- out.full_bias_ns = in.full_bias_ns;
- out.bias_ns = in.bias_ns;
- out.bias_uncertainty_ns = in.bias_uncertainty_ns;
- out.drift_nsps = in.drift_nsps;
- out.drift_uncertainty_nsps = in.drift_uncertainty_nsps;
- out.hw_clock_discontinuity_count = in.hw_clock_discontinuity_count;
-}
-
-void Q2A_GnssData(const LocGnssData& in, GnssData& out) {
- memset(&out, 0, sizeof(GnssData));
- out.size = sizeof(GnssData);
- out.measurement_count = in.measurement_count;
- int len = LOC_GNSS_MAX_MEASUREMENT < GNSS_MAX_MEASUREMENT
- ? LOC_GNSS_MAX_MEASUREMENT : GNSS_MAX_MEASUREMENT;
- for (int i = 0; i < len; i++) {
- Q2A_GnssMeasurement(in.measurements[i], out.measurements[i]);
- }
- Q2A_GnssClock(in.clock, out.clock);
-}
diff --git a/msm8998/loc_api/libloc_api_50001/gps_converter.h b/msm8998/loc_api/libloc_api_50001/gps_converter.h
deleted file mode 100644
index fa7c68a..0000000
--- a/msm8998/loc_api/libloc_api_50001/gps_converter.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* Copyright (c) 2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef __GPS_CONVERTER_H__
-#define __GPS_CONVERTER_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include <ctype.h>
-#include <hardware/gps.h>
-#include <gps_extended.h>
-
-#define A2Q_GpsAidingData(in) (LocGpsAidingData)in
-#define A2Q_GpsUserResponseType(in) (LocGpsUserResponseType)in
-#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in
-#define A2Q_GpsUtcTime(in) (LocGpsUtcTime)in
-#define A2Q_GpsPositionMode(in) (LocGpsPositionMode)in
-#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in
-#define A2Q_ApnIpType(in) (LocApnIpType)in
-#define A2Q_AGpsType(in) (LocAGpsType)in
-#define A2Q_GpsPositionRecurrence(in) (LocGpsPositionRecurrence)in
-
-#define Q2A_GpsUtcTime(in) (GpsUtcTime)in
-
-void A2Q_DerEncodedCertificate(const DerEncodedCertificate& in, LocDerEncodedCertificate& out);
-
-void Q2A_GpsLocation(const LocGpsLocation& in, GpsLocation& out);
-void Q2A_GpsSvStatus(const LocGpsSvStatus& in, GpsSvStatus& out);
-void Q2A_GnssSvStatus(const LocGnssSvStatus& in, GnssSvStatus& out);
-void Q2A_GpsNiNotification(const LocGpsNiNotification& in, GpsNiNotification& out);
-void Q2A_GpsStatus(const LocGpsStatus& in, GpsStatus& out);
-void Q2A_GnssSystemInfo(const LocGnssSystemInfo& in, GnssSystemInfo& out);
-void Q2A_AGpsStatus(const LocAGpsStatus& in, AGpsStatus& out);
-void Q2A_GpsData(const LocGpsData& in, GpsData& out);
-void Q2A_GnssData(const LocGnssData& in, GnssData& out);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif //__GPS_CONVERTER_H__
diff --git a/msm8998/loc_api/libloc_api_50001/gps_interface.cpp b/msm8998/loc_api/libloc_api_50001/gps_interface.cpp
deleted file mode 100644
index bd52914..0000000
--- a/msm8998/loc_api/libloc_api_50001/gps_interface.cpp
+++ /dev/null
@@ -1,1194 +0,0 @@
-/* Copyright (c) 2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "GpsInterface"
-
-#include <hardware/gps.h>
-#include <gps_extended.h>
-#include <gps_converter.h>
-#include <loc_eng.h>
-#include <loc_target.h>
-#include <loc_log.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <dlfcn.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <LocDualContext.h>
-#include <platform_lib_includes.h>
-#include <cutils/properties.h>
-
-using namespace loc_core;
-
-// All functions and variables should be static
-// except gps_get_hardware_interface() and get_gps_interface()
-
-extern "C" const LocGpsInterface* loc_eng_gps_get_hardware_interface ();
-extern "C" const LocGpsInterface* loc_eng_get_gps_interface();
-
-/*===========================================================================
- Functions and variables for sGpsInterface
-===========================================================================*/
-static const LocGpsInterface* pLocGpsInterface = NULL;
-
-static GpsCallbacks sGpsCallbacks;
-static GpsCallbacks* pGpsCallbacks = NULL;
-
-static void local_gps_location_callback(LocGpsLocation* location);
-static void local_gps_sv_status_callback(LocGpsSvStatus* sv_status);
-static void local_gps_status_callback(LocGpsStatus* status);
-static void local_gps_nmea_callback(LocGpsUtcTime timestamp, const char* nmea, int length);
-static void local_gps_set_capabilities(uint32_t capabilities);
-static void local_gps_acquire_wakelock();
-static void local_gps_release_wakelock();
-static pthread_t local_gps_create_thread(const char* name, void (*start)(void *), void* arg);
-static void local_gps_request_utc_time();
-static void local_gnss_set_system_info(const LocGnssSystemInfo* info);
-static void local_gnss_sv_status_callback(LocGnssSvStatus* sv_info);
-
-static LocGpsCallbacks sLocGpsCallbacks = {
- sizeof(LocGpsCallbacks),
- local_gps_location_callback,
- local_gps_status_callback,
- local_gps_sv_status_callback,
- local_gps_nmea_callback,
- local_gps_set_capabilities,
- local_gps_acquire_wakelock,
- local_gps_release_wakelock,
- local_gps_create_thread,
- local_gps_request_utc_time,
- local_gnss_set_system_info,
- local_gnss_sv_status_callback,
-};
-
-static int loc_init(GpsCallbacks* callbacks);
-static int loc_start();
-static int loc_stop();
-static void loc_cleanup();
-static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty);
-static int loc_inject_location(double latitude, double longitude, float accuracy);
-static void loc_delete_aiding_data(GpsAidingData f);
-static int loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence,
- uint32_t min_interval, uint32_t preferred_accuracy,
- uint32_t preferred_time);
-static const void* loc_get_extension(const char* name);
-
-static const GpsInterface sGpsInterface = {
- sizeof(GpsInterface),
- loc_init,
- loc_start,
- loc_stop,
- loc_cleanup,
- loc_inject_time,
- loc_inject_location,
- loc_delete_aiding_data,
- loc_set_position_mode,
- loc_get_extension
-};
-
-/*===========================================================================
- Functions and variables for sGpsXtraInterface
-===========================================================================*/
-static const LocGpsXtraInterface* pLocGpsXtraInterface = NULL;
-
-static GpsXtraCallbacks sGpsXtraCallbacks;
-static GpsXtraCallbacks* pGpsXtraCallbacks = NULL;
-
-static void local_gps_xtra_download_request();
-static pthread_t local_gps_xtra_create_thread(const char* name, void (*start)(void *), void* arg);
-
-static LocGpsXtraCallbacks sLocGpsXtraCallbacks = {
- local_gps_xtra_download_request,
- local_gps_xtra_create_thread
-};
-
-static int loc_xtra_init(GpsXtraCallbacks* callbacks);
-static int loc_xtra_inject_data(char* data, int length);
-
-static const GpsXtraInterface sGpsXtraInterface = {
- sizeof(GpsXtraInterface),
- loc_xtra_init,
- loc_xtra_inject_data
-};
-
-/*===========================================================================
- Functions and variables for sAGpsInterface
-===========================================================================*/
-static const LocAGpsInterface* pLocAGpsInterface = NULL;
-
-static AGpsCallbacks sAGpsCallbacks;
-static AGpsCallbacks* pAGpsCallbacks = NULL;
-
-static void local_agps_status_callback(LocAGpsStatus* status);
-static pthread_t local_agps_create_thread(const char* name, void (*start)(void *), void* arg);
-
-static LocAGpsCallbacks sLocAGpsCallbacks = {
- local_agps_status_callback,
- local_agps_create_thread
-};
-
-static void loc_agps_init(AGpsCallbacks* callbacks);
-static int loc_agps_open(const char* apn);
-static int loc_agps_closed();
-static int loc_agps_open_failed();
-static int loc_agps_set_server(AGpsType type, const char *hostname, int port);
-static int loc_agps_open_with_apniptype( const char* apn, ApnIpType apnIpType);
-
-static const AGpsInterface sAGpsInterface = {
- sizeof(AGpsInterface),
- loc_agps_init,
- loc_agps_open,
- loc_agps_closed,
- loc_agps_open_failed,
- loc_agps_set_server,
- loc_agps_open_with_apniptype
-};
-
-/*===========================================================================
- Functions and variables for SUPL sSuplCertificateInterface
-===========================================================================*/
-static const LocSuplCertificateInterface* pLocSuplCertificateInterface = NULL;
-
-static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
- size_t length);
-static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
- size_t length);
-
-static const SuplCertificateInterface sSuplCertificateInterface =
-{
- sizeof(SuplCertificateInterface),
- loc_agps_install_certificates,
- loc_agps_revoke_certificates
-};
-
-/*===========================================================================
- Functions and variables for sGpsNiInterface
-===========================================================================*/
-static const LocGpsNiInterface* pLocGpsNiInterface = NULL;
-
-static GpsNiCallbacks sGpsNiCallbacks;
-static GpsNiCallbacks* pGpsNiCallbacks = NULL;
-
-static void local_gps_ni_notify_callback(LocGpsNiNotification *notification);
-static pthread_t local_gps_ni_create_thread(const char* name, void (*start)(void *), void* arg);
-
-static LocGpsNiCallbacks sLocGpsNiCallbacks = {
- local_gps_ni_notify_callback,
- local_gps_ni_create_thread
-};
-
-static void loc_ni_init(GpsNiCallbacks *callbacks);
-static void loc_ni_respond(int notif_id, GpsUserResponseType user_response);
-
-static const GpsNiInterface sGpsNiInterface =
-{
- sizeof(GpsNiInterface),
- loc_ni_init,
- loc_ni_respond,
-};
-
-/*===========================================================================
- Functions and variables for sAGpsRilInterface
-===========================================================================*/
-static const LocAGpsRilInterface* pLocAGpsRilInterface = NULL;
-
-static void loc_agps_ril_init(AGpsRilCallbacks* callbacks);
-static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct);
-static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid);
-static void loc_agps_ril_ni_message(uint8_t *msg, size_t len);
-static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info);
-static void loc_agps_ril_update_network_availability(int avaiable, const char* apn);
-
-static const AGpsRilInterface sAGpsRilInterface =
-{
- sizeof(AGpsRilInterface),
- loc_agps_ril_init,
- loc_agps_ril_set_ref_location,
- loc_agps_ril_set_set_id,
- loc_agps_ril_ni_message,
- loc_agps_ril_update_network_state,
- loc_agps_ril_update_network_availability
-};
-
-/*===========================================================================
- Functions and variables for sGpsGeofencingInterface
-===========================================================================*/
-static const LocGpsGeofencingInterface* pLocGpsGeofencingInterface = NULL;
-
-static GpsGeofenceCallbacks sGpsGeofenceCallbacks;
-static GpsGeofenceCallbacks* pGpsGeofenceCallbacks = NULL;
-
-static void local_gps_geofence_transition_callback(int32_t geofence_id, LocGpsLocation* location,
- int32_t transition, LocGpsUtcTime timestamp);
-static void local_gps_geofence_status_callback(int32_t status, LocGpsLocation* last_location);
-static void local_gps_geofence_add_callback(int32_t geofence_id, int32_t status);
-static void local_gps_geofence_remove_callback(int32_t geofence_id, int32_t status);
-static void local_gps_geofence_pause_callback(int32_t geofence_id, int32_t status);
-static void local_gps_geofence_resume_callback(int32_t geofence_id, int32_t status);
-static pthread_t local_geofence_create_thread(const char* name, void (*start)(void *), void* arg);
-
-static LocGpsGeofenceCallbacks sLocGpsGeofenceCallbacks =
-{
- local_gps_geofence_transition_callback,
- local_gps_geofence_status_callback,
- local_gps_geofence_add_callback,
- local_gps_geofence_remove_callback,
- local_gps_geofence_pause_callback,
- local_gps_geofence_resume_callback,
- local_geofence_create_thread
-};
-
-static void loc_geofence_init(GpsGeofenceCallbacks* callbacks);
-static void loc_add_geofence_area(int32_t geofence_id, double latitude, double longitude,
- double radius_meters, int last_transition, int monitor_transitions,
- int notification_responsiveness_ms, int unknown_timer_ms);
-static void loc_pause_geofence(int32_t geofence_id);
-static void loc_resume_geofence(int32_t geofence_id, int monitor_transitions);
-static void loc_remove_geofence_area(int32_t geofence_id);
-
-static const GpsGeofencingInterface sGpsGeofencingInterface =
-{
- sizeof(GpsGeofencingInterface),
- loc_geofence_init,
- loc_add_geofence_area,
- loc_pause_geofence,
- loc_resume_geofence,
- loc_remove_geofence_area
-};
-
-/*===========================================================================
- Functions and variables for sGpsMeasurementInterface
-===========================================================================*/
-static const LocGpsMeasurementInterface* pLocGpsMeasurementInterface = NULL;
-
-static GpsMeasurementCallbacks sGpsMeasurementCallbacks;
-static GpsMeasurementCallbacks* pGpsMeasurementCallbacks = NULL;
-
-static void local_gps_measurement_callback(LocGpsData* data);
-static void local_gnss_measurement_callback(LocGnssData* data);
-
-static LocGpsMeasurementCallbacks sLocGpsMeasurementCallbacks =
-{
- sizeof(LocGpsMeasurementCallbacks),
- local_gps_measurement_callback,
- local_gnss_measurement_callback
-};
-
-static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks);
-static void loc_gps_measurement_close();
-
-static const GpsMeasurementInterface sGpsMeasurementInterface =
-{
- sizeof(GpsMeasurementInterface),
- loc_gps_measurement_init,
- loc_gps_measurement_close
-};
-
-/*===========================================================================
- Functions and variables for sGnssConfigurationInterface
-===========================================================================*/
-static const LocGnssConfigurationInterface* pLocGnssConfigurationInterface = NULL;
-
-static void loc_configuration_update(const char* config_data, int32_t length);
-
-static const GnssConfigurationInterface sGnssConfigurationInterface =
-{
- sizeof(GnssConfigurationInterface),
- loc_configuration_update
-};
-
-
-/*===========================================================================
-FUNCTION gps_get_hardware_interface
-
-DESCRIPTION
- Returns the GPS hardware interaface based on LOC API
- if GPS is enabled.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-extern "C" const GpsInterface* gps_get_hardware_interface ()
-{
- ENTRY_LOG_CALLFLOW();
- const GpsInterface* retVal;
- pLocGpsInterface = loc_eng_gps_get_hardware_interface();
- if (NULL != pLocGpsInterface) {
- retVal = &sGpsInterface;
- } else {
- retVal = NULL;
- }
- EXIT_LOG(%p, retVal);
- return retVal;
-}
-
-// for gps.c
-extern "C" const GpsInterface* get_gps_interface()
-{
- pLocGpsInterface = loc_eng_get_gps_interface();
- return &sGpsInterface;
-}
-
-/*===========================================================================
- Implementation of functions for sGpsInterface
-===========================================================================*/
-static void local_gps_location_callback(LocGpsLocation* location)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->location_cb) {
- GpsLocation loc;
- GpsLocation* p_loc = NULL;
- if (NULL != location) {
- Q2A_GpsLocation(*location, loc);
- p_loc = &loc;
- }
- // We are not sure whether NULL pointer is a legal
- // parameter to the original callback functions or not.
- // So we should forward NULL pointer at this layer.
- pGpsCallbacks->location_cb(p_loc);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_sv_status_callback(LocGpsSvStatus* sv_status)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->sv_status_cb) {
- CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs);
- GpsSvStatus st;
- GpsSvStatus* p_st = NULL;
- if (NULL != sv_status) {
- Q2A_GpsSvStatus(*sv_status, st);
- p_st = &st;
- }
- pGpsCallbacks->sv_status_cb(p_st);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_status_callback(LocGpsStatus* status)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->status_cb) {
- GpsStatus st;
- GpsStatus* p_st = NULL;
- if (NULL != status) {
- Q2A_GpsStatus(*status, st);
- p_st = &st;
- }
- pGpsCallbacks->status_cb(p_st);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_nmea_callback(LocGpsUtcTime timestamp, const char* nmea, int length)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->nmea_cb) {
- pGpsCallbacks->nmea_cb(A2Q_GpsUtcTime(timestamp), nmea, length);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_set_capabilities(uint32_t capabilities)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->set_capabilities_cb) {
- pGpsCallbacks->set_capabilities_cb(capabilities);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_acquire_wakelock()
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->acquire_wakelock_cb) {
- pGpsCallbacks->acquire_wakelock_cb();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_release_wakelock()
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->release_wakelock_cb) {
- pGpsCallbacks->release_wakelock_cb();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static pthread_t local_gps_create_thread(const char* name, void (*start)(void *), void* arg)
-{
- ENTRY_LOG();
- pthread_t retVal = -1;
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->create_thread_cb) {
- retVal = pGpsCallbacks->create_thread_cb(name, start, arg);
- }
- EXIT_LOG(%d, (int)retVal);
- return retVal;
-}
-
-static void local_gps_request_utc_time()
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->request_utc_time_cb) {
- pGpsCallbacks->request_utc_time_cb();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gnss_set_system_info(const LocGnssSystemInfo* info)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->set_system_info_cb) {
- GnssSystemInfo sysinfo;
- GnssSystemInfo* p_sysinfo = NULL;
- if (NULL != info) {
- Q2A_GnssSystemInfo(*info, sysinfo);
- p_sysinfo = &sysinfo;
- }
- pGpsCallbacks->set_system_info_cb(p_sysinfo);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gnss_sv_status_callback(LocGnssSvStatus* sv_info)
-{
- ENTRY_LOG();
- if (NULL != pGpsCallbacks && NULL != pGpsCallbacks->gnss_sv_status_cb) {
- GnssSvStatus info;
- GnssSvStatus* p_info = NULL;
- if (NULL != sv_info) {
- Q2A_GnssSvStatus(*sv_info, info);
- p_info = &info;
- }
- pGpsCallbacks->gnss_sv_status_cb(p_info);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_init(GpsCallbacks* callbacks)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- LocGpsCallbacks* cbs = NULL;
- if (NULL != callbacks) {
- memcpy(&sGpsCallbacks, callbacks, sizeof(GpsCallbacks));
- pGpsCallbacks = &sGpsCallbacks;
- cbs = &sLocGpsCallbacks;
- }
-
- if(NULL != pLocGpsInterface && NULL != pLocGpsInterface->init) {
- retVal = pLocGpsInterface->init(cbs);
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_start()
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->start) {
- retVal = pLocGpsInterface->start();
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_stop()
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->stop) {
- retVal = pLocGpsInterface->stop();
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static void loc_cleanup()
-{
- ENTRY_LOG();
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->cleanup) {
- pLocGpsInterface->cleanup();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty)
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->inject_time) {
- retVal = pLocGpsInterface->inject_time(A2Q_GpsUtcTime(time),
- timeReference, uncertainty);
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_inject_location(double latitude, double longitude, float accuracy)
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->inject_location) {
- retVal = pLocGpsInterface->inject_location(latitude, longitude, accuracy);
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static void loc_delete_aiding_data(GpsAidingData f)
-{
- ENTRY_LOG();
-
-#ifndef TARGET_BUILD_VARIANT_USER
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->delete_aiding_data) {
- pLocGpsInterface->delete_aiding_data(A2Q_GpsAidingData(f));
- }
-#endif
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_set_position_mode(GpsPositionMode mode,
- GpsPositionRecurrence recurrence,
- uint32_t min_interval,
- uint32_t preferred_accuracy,
- uint32_t preferred_time)
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->set_position_mode) {
- retVal = pLocGpsInterface->set_position_mode(A2Q_GpsPositionMode(mode),
- A2Q_GpsPositionRecurrence(recurrence),
- min_interval, preferred_accuracy, preferred_time);
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-const void* loc_get_extension(const char* name)
-{
- ENTRY_LOG();
- const void* retVal = NULL;
-
- LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name);
- if (NULL != pLocGpsInterface && NULL != pLocGpsInterface->get_extension) {
- if (strcmp(name, GPS_XTRA_INTERFACE) == 0)
- {
- pLocGpsXtraInterface = (const LocGpsXtraInterface*)pLocGpsInterface->
- get_extension(LOC_GPS_XTRA_INTERFACE);
- if (NULL != pLocGpsXtraInterface) {
- retVal = &sGpsXtraInterface;
- }
- }
- else if (strcmp(name, AGPS_INTERFACE) == 0)
- {
- pLocAGpsInterface = (const LocAGpsInterface*)pLocGpsInterface->
- get_extension(LOC_AGPS_INTERFACE);
- if (NULL != pLocAGpsInterface) {
- retVal = &sAGpsInterface;
- }
- }
- else if (strcmp(name, SUPL_CERTIFICATE_INTERFACE) == 0)
- {
- pLocSuplCertificateInterface = (const LocSuplCertificateInterface*)pLocGpsInterface->
- get_extension(LOC_SUPL_CERTIFICATE_INTERFACE);
- if (NULL != pLocAGpsInterface) {
- retVal = &sSuplCertificateInterface;
- }
- }
- else if (strcmp(name, GPS_NI_INTERFACE) == 0)
- {
- pLocGpsNiInterface = (const LocGpsNiInterface*)pLocGpsInterface->
- get_extension(LOC_GPS_NI_INTERFACE);
- if (NULL != pLocGpsNiInterface) {
- retVal = &sGpsNiInterface;
- }
- }
- else if (strcmp(name, AGPS_RIL_INTERFACE) == 0)
- {
- pLocAGpsRilInterface = (const LocAGpsRilInterface*)pLocGpsInterface->
- get_extension(LOC_AGPS_RIL_INTERFACE);
- if (NULL != pLocAGpsRilInterface) {
- retVal = &sAGpsRilInterface;
- }
- }
- else if (strcmp(name, GPS_GEOFENCING_INTERFACE) == 0)
- {
- pLocGpsGeofencingInterface = (const LocGpsGeofencingInterface*)pLocGpsInterface->
- get_extension(LOC_GPS_GEOFENCING_INTERFACE);
- if (NULL != pLocGpsGeofencingInterface) {
- retVal = &sGpsGeofencingInterface;
- }
- }
- else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0)
- {
- pLocGpsMeasurementInterface = (const LocGpsMeasurementInterface*)pLocGpsInterface->
- get_extension(LOC_GPS_MEASUREMENT_INTERFACE);
- if (NULL != pLocGpsMeasurementInterface) {
- retVal = &sGpsMeasurementInterface;
- }
- }
- else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0)
- {
- pLocGnssConfigurationInterface = (const LocGnssConfigurationInterface*)pLocGpsInterface->
- get_extension(LOC_GNSS_CONFIGURATION_INTERFACE);
- if (NULL != pLocGnssConfigurationInterface) {
- retVal = &sGnssConfigurationInterface;
- }
- }
- else
- {
- LOC_LOGE ("get_extension: Invalid interface passed in\n");
- }
- }
- EXIT_LOG(%p, retVal);
- return retVal;
-}
-
-/*===========================================================================
- Implementation of functions for sGpsXtraInterface
-===========================================================================*/
-static void local_gps_xtra_download_request()
-{
- ENTRY_LOG();
- if (NULL != pGpsXtraCallbacks && NULL != pGpsXtraCallbacks->download_request_cb) {
- pGpsXtraCallbacks->download_request_cb();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static pthread_t local_gps_xtra_create_thread(const char* name, void (*start)(void *), void* arg)
-{
- ENTRY_LOG();
- pthread_t retVal = -1;
- if (NULL != pGpsXtraCallbacks && NULL != pGpsXtraCallbacks->create_thread_cb) {
- retVal = pGpsXtraCallbacks->create_thread_cb(name, start, arg);
- }
- EXIT_LOG(%d, (int)retVal);
- return retVal;
-}
-
-static int loc_xtra_init(GpsXtraCallbacks* callbacks)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- LocGpsXtraCallbacks* cbs = NULL;
- if (NULL != callbacks)
- {
- memcpy(&sGpsXtraCallbacks, callbacks, sizeof(GpsXtraCallbacks));
- pGpsXtraCallbacks = &sGpsXtraCallbacks;
- cbs = &sLocGpsXtraCallbacks;
- }
-
- if (NULL != pLocGpsXtraInterface && NULL != pLocGpsXtraInterface->init) {
- retVal = pLocGpsXtraInterface->init(cbs);
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-
-static int loc_xtra_inject_data(char* data, int length)
-{
- ENTRY_LOG();
- int retVal = -1;
- if (NULL != pLocGpsXtraInterface && NULL != pLocGpsXtraInterface->inject_xtra_data) {
- retVal = pLocGpsXtraInterface->inject_xtra_data(data, length);
- }
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-/*===========================================================================
- Implementation of functions for sAGpsInterface
-===========================================================================*/
-static void local_agps_status_callback(LocAGpsStatus* status)
-{
- ENTRY_LOG();
- if (NULL != pAGpsCallbacks && NULL != pAGpsCallbacks->status_cb) {
- AGpsStatus st;
- AGpsStatus* p_st = NULL;
- if (NULL != status)
- {
- Q2A_AGpsStatus(*status, st);
- p_st = &st;
- }
- pAGpsCallbacks->status_cb(p_st);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static pthread_t local_agps_create_thread(const char* name, void (*start)(void *), void* arg)
-{
- ENTRY_LOG();
- pthread_t retVal = -1;
- if (NULL != pAGpsCallbacks && NULL != pAGpsCallbacks->create_thread_cb) {
- retVal = pAGpsCallbacks->create_thread_cb(name, start, arg);
- }
- EXIT_LOG(%d, (int)retVal);
- return retVal;
-}
-
-static void loc_agps_init(AGpsCallbacks* callbacks)
-{
- ENTRY_LOG();
-
- LocAGpsCallbacks* cbs = NULL;
- if (NULL != callbacks)
- {
- memcpy(&sAGpsCallbacks, callbacks, sizeof(AGpsCallbacks));
- pAGpsCallbacks = &sAGpsCallbacks;
- cbs = &sLocAGpsCallbacks;
- }
-
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->init) {
- pLocAGpsInterface->init(cbs);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_agps_open(const char* apn)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_open) {
- retVal = pLocAGpsInterface->data_conn_open(apn);
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_agps_closed()
-{
- ENTRY_LOG();
-
- int retVal = -1;
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_closed) {
- retVal = pLocAGpsInterface->data_conn_closed();
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-int loc_agps_open_failed()
-{
- ENTRY_LOG();
-
- int retVal = -1;
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_failed) {
- retVal = pLocAGpsInterface->data_conn_failed();
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_agps_set_server(AGpsType type, const char* hostname, int port)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->set_server) {
- retVal = pLocAGpsInterface->set_server(A2Q_AGpsType(type), hostname, port);
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- if (NULL != pLocAGpsInterface && NULL != pLocAGpsInterface->data_conn_open_with_apn_ip_type) {
- retVal = pLocAGpsInterface->data_conn_open_with_apn_ip_type(apn, A2Q_ApnIpType(apnIpType));
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-/*===========================================================================
- Implementation of functions for sSuplCertificateInterface
-===========================================================================*/
-static int loc_agps_install_certificates(const DerEncodedCertificate* certificates,
- size_t length)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- LocDerEncodedCertificate cert;
- LocDerEncodedCertificate* p_cert = NULL;
- if (NULL != certificates) {
- A2Q_DerEncodedCertificate(*certificates, cert);
- p_cert = &cert;
- }
-
- if (NULL != pLocSuplCertificateInterface &&
- NULL != pLocSuplCertificateInterface->install_certificates) {
- retVal = pLocSuplCertificateInterface->install_certificates(p_cert, length);
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints,
- size_t length)
-{
- ENTRY_LOG();
- LOC_LOGE("%s:%d] agps_revoke_certificates not supported", __func__, __LINE__);
- int retVal = AGPS_CERTIFICATE_ERROR_GENERIC;
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-/*===========================================================================
- Implementation of functions for sGpsNiInterface
-===========================================================================*/
-static void local_gps_ni_notify_callback(LocGpsNiNotification *notification)
-{
- ENTRY_LOG();
- if (NULL != pGpsNiCallbacks && NULL != pGpsNiCallbacks->notify_cb) {
- GpsNiNotification notify;
- GpsNiNotification* p_notify = NULL;
- if (NULL != notification) {
- Q2A_GpsNiNotification(*notification, notify);
- p_notify = ¬ify;
- }
- pGpsNiCallbacks->notify_cb(p_notify);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static pthread_t local_gps_ni_create_thread(const char* name, void (*start)(void *), void* arg)
-{
- ENTRY_LOG();
- pthread_t retVal = -1;
- if (NULL != pGpsNiCallbacks && NULL != pGpsNiCallbacks->create_thread_cb) {
- retVal = pGpsNiCallbacks->create_thread_cb(name, start, arg);
- }
- EXIT_LOG(%d, (int)retVal);
- return retVal;
-}
-
-void loc_ni_init(GpsNiCallbacks *callbacks)
-{
- ENTRY_LOG();
-
- LocGpsNiCallbacks* cbs = NULL;
- if (NULL != callbacks) {
- memcpy(&sGpsNiCallbacks, callbacks, sizeof(GpsNiCallbacks));
- pGpsNiCallbacks = &sGpsNiCallbacks;
- cbs = &sLocGpsNiCallbacks;
- }
-
- if(NULL != pLocGpsNiInterface && NULL != pLocGpsNiInterface->init) {
- pLocGpsNiInterface->init(cbs);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-void loc_ni_respond(int notif_id, GpsUserResponseType user_response)
-{
- ENTRY_LOG();
-
- if(NULL != pLocGpsNiInterface && NULL != pLocGpsNiInterface->respond) {
- pLocGpsNiInterface->respond(notif_id, A2Q_GpsUserResponseType(user_response));
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
- Implementation of functions for sAGpsRilInterface
-===========================================================================*/
-// Below stub functions are members of sAGpsRilInterface
-static void loc_agps_ril_init( AGpsRilCallbacks* callbacks ) {}
-static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct) {}
-static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid) {}
-static void loc_agps_ril_ni_message(uint8_t *msg, size_t len) {}
-static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info) {}
-
-static void loc_agps_ril_update_network_availability(int available, const char* apn)
-{
- ENTRY_LOG();
-
- if (NULL != pLocAGpsRilInterface &&
- NULL != pLocAGpsRilInterface->update_network_availability) {
- pLocAGpsRilInterface->update_network_availability(available, apn);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
- Implementation of functions for sGpsGeofencingInterface
-===========================================================================*/
-static void local_gps_geofence_transition_callback(int32_t geofence_id, LocGpsLocation* location,
- int32_t transition, LocGpsUtcTime timestamp)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_transition_callback) {
- GpsLocation loc;
- GpsLocation* p_loc = NULL;
- if (NULL != location)
- {
- Q2A_GpsLocation(*location, loc);
- p_loc = &loc;
- }
- pGpsGeofenceCallbacks->geofence_transition_callback(geofence_id, p_loc, transition, Q2A_GpsUtcTime(timestamp));
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_geofence_status_callback(int32_t status, LocGpsLocation* last_location)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_status_callback) {
- GpsLocation loc;
- GpsLocation* p_loc = NULL;
- if (NULL != last_location)
- {
- Q2A_GpsLocation(*last_location, loc);
- p_loc = &loc;
- }
- pGpsGeofenceCallbacks->geofence_status_callback(status, p_loc);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_geofence_add_callback(int32_t geofence_id, int32_t status)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_add_callback) {
- pGpsGeofenceCallbacks->geofence_add_callback(geofence_id, status);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_geofence_remove_callback(int32_t geofence_id, int32_t status)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_remove_callback) {
- pGpsGeofenceCallbacks->geofence_remove_callback(geofence_id, status);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_geofence_pause_callback(int32_t geofence_id, int32_t status)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_pause_callback) {
- pGpsGeofenceCallbacks->geofence_pause_callback(geofence_id, status);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gps_geofence_resume_callback(int32_t geofence_id, int32_t status)
-{
- ENTRY_LOG();
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->geofence_resume_callback) {
- pGpsGeofenceCallbacks->geofence_resume_callback(geofence_id, status);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static pthread_t local_geofence_create_thread(const char* name, void (*start)(void *), void* arg)
-{
- ENTRY_LOG();
- pthread_t retVal = -1;
- if (NULL != pGpsGeofenceCallbacks && NULL != pGpsGeofenceCallbacks->create_thread_cb) {
- retVal = pGpsGeofenceCallbacks->create_thread_cb(name, start, arg);
- }
- EXIT_LOG(%d, (int)retVal);
- return retVal;
-}
-
-static void loc_geofence_init(GpsGeofenceCallbacks* callbacks)
-{
- ENTRY_LOG();
- if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->init) {
- LocGpsGeofenceCallbacks* cbs = NULL;
- if (NULL != callbacks) {
- memcpy(&sGpsGeofenceCallbacks, callbacks, sizeof(GpsGeofenceCallbacks));
- pGpsGeofenceCallbacks = &sGpsGeofenceCallbacks;
- cbs = &sLocGpsGeofenceCallbacks;
- }
- pLocGpsGeofencingInterface->init(cbs);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void loc_add_geofence_area(int32_t geofence_id, double latitude, double longitude,
- double radius_meters, int last_transition, int monitor_transitions,
- int notification_responsiveness_ms, int unknown_timer_ms)
-{
- ENTRY_LOG();
- if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->add_geofence_area) {
- pLocGpsGeofencingInterface->add_geofence_area(geofence_id, latitude, longitude,
- radius_meters, last_transition, monitor_transitions,
- notification_responsiveness_ms, unknown_timer_ms);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void loc_pause_geofence(int32_t geofence_id)
-{
- ENTRY_LOG();
- if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->pause_geofence) {
- pLocGpsGeofencingInterface->pause_geofence(geofence_id);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void loc_resume_geofence(int32_t geofence_id, int monitor_transitions)
-{
- ENTRY_LOG();
- if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->resume_geofence) {
- pLocGpsGeofencingInterface->resume_geofence(geofence_id, monitor_transitions);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void loc_remove_geofence_area(int32_t geofence_id)
-{
- ENTRY_LOG();
- if (NULL != pLocGpsGeofencingInterface && NULL != pLocGpsGeofencingInterface->remove_geofence_area) {
- pLocGpsGeofencingInterface->remove_geofence_area(geofence_id);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
- Implementation of functions for sGpsMeasurementInterface
-===========================================================================*/
-static void local_gps_measurement_callback(LocGpsData* data)
-{
- ENTRY_LOG();
- if (NULL != pGpsMeasurementCallbacks && NULL != pGpsMeasurementCallbacks->measurement_callback) {
- GpsData gps_data;
- GpsData* p_gps_data = NULL;
- if (NULL != data)
- {
- Q2A_GpsData(*data, gps_data);
- p_gps_data = &gps_data;
- }
- pGpsMeasurementCallbacks->measurement_callback(p_gps_data);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_gnss_measurement_callback(LocGnssData* data)
-{
- ENTRY_LOG();
- if (NULL != pGpsMeasurementCallbacks && NULL != pGpsMeasurementCallbacks->gnss_measurement_callback) {
- GnssData gnss_data;
- GnssData* p_gnss_data = NULL;
- if (NULL != data)
- {
- Q2A_GnssData(*data, gnss_data);
- p_gnss_data = &gnss_data;
- }
- pGpsMeasurementCallbacks->gnss_measurement_callback(p_gnss_data);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks)
-{
- ENTRY_LOG();
-
- int retVal = -1;
- LocGpsMeasurementCallbacks* cbs = NULL;
- if (NULL != callbacks)
- {
- memcpy(&sGpsMeasurementCallbacks, callbacks, sizeof(GpsMeasurementCallbacks));
- pGpsMeasurementCallbacks = &sGpsMeasurementCallbacks;
- cbs = &sLocGpsMeasurementCallbacks;
-
- if (NULL != pLocGpsMeasurementInterface && NULL != pLocGpsMeasurementInterface->init) {
- retVal = pLocGpsMeasurementInterface->init(cbs);
- }
- }
-
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-static void loc_gps_measurement_close()
-{
- ENTRY_LOG();
-
- if (NULL != pLocGpsMeasurementInterface && NULL != pLocGpsMeasurementInterface->close) {
- pLocGpsMeasurementInterface->close();
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
- Implementation of functions for sGnssConfigurationInterface
-===========================================================================*/
-static void loc_configuration_update(const char* config_data, int32_t length)
-{
- ENTRY_LOG();
-
- if (NULL != pLocGnssConfigurationInterface &&
- NULL != pLocGnssConfigurationInterface->configuration_update) {
- pLocGnssConfigurationInterface->configuration_update(config_data, length);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc.cpp b/msm8998/loc_api/libloc_api_50001/loc.cpp
deleted file mode 100644
index 8c021b3..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc.cpp
+++ /dev/null
@@ -1,1119 +0,0 @@
-/* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_afw"
-
-#include <gps_extended.h>
-#include <loc_eng.h>
-#include <loc_target.h>
-#include <loc_log.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <dlfcn.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <LocDualContext.h>
-#include <platform_lib_includes.h>
-#include <cutils/properties.h>
-
-using namespace loc_core;
-
-// All functions and variables should be static
-// except loc_eng_gps_get_hardware_interface() and loc_eng_get_gps_interface()
-
-//Globals defns
-static loc_gps_location_callback gps_loc_cb = NULL;
-static loc_gps_sv_status_callback gps_sv_cb = NULL;
-
-static void local_loc_cb(UlpLocation* location, void* locExt);
-static void local_sv_cb(LocGpsSvStatus* sv_status, void* svExt);
-
-static const LocGpsGeofencingInterface* get_geofence_interface(void);
-
-// Function declarations for sLocEngInterface
-static int loc_init(LocGpsCallbacks* callbacks);
-static int loc_start();
-static int loc_stop();
-static void loc_cleanup();
-static int loc_inject_time(LocGpsUtcTime time, int64_t timeReference, int uncertainty);
-static int loc_inject_location(double latitude, double longitude, float accuracy);
-static void loc_delete_aiding_data(LocGpsAidingData f);
-static int loc_set_position_mode(LocGpsPositionMode mode, LocGpsPositionRecurrence recurrence,
- uint32_t min_interval, uint32_t preferred_accuracy,
- uint32_t preferred_time);
-static const void* loc_get_extension(const char* name);
-static const LocGpsInterface sLocEngInterface =
-{
- sizeof(LocGpsInterface),
- loc_init,
- loc_start,
- loc_stop,
- loc_cleanup,
- loc_inject_time,
- loc_inject_location,
- loc_delete_aiding_data,
- loc_set_position_mode,
- loc_get_extension
-};
-
-// Function declarations for sLocEngAGpsInterface
-static void loc_agps_init(LocAGpsCallbacks* callbacks);
-static int loc_agps_open(const char* apn);
-static int loc_agps_closed();
-static int loc_agps_open_failed();
-static int loc_agps_set_server(LocAGpsType type, const char *hostname, int port);
-static int loc_agps_open_with_apniptype( const char* apn, LocApnIpType apnIpType);
-
-static const LocAGpsInterface sLocEngAGpsInterface =
-{
- sizeof(LocAGpsInterface),
- loc_agps_init,
- loc_agps_open,
- loc_agps_closed,
- loc_agps_open_failed,
- loc_agps_set_server,
- loc_agps_open_with_apniptype
-};
-
-static int loc_xtra_init(LocGpsXtraCallbacks* callbacks);
-static int loc_xtra_inject_data(char* data, int length);
-
-static const LocGpsXtraInterface sLocEngXTRAInterface =
-{
- sizeof(LocGpsXtraInterface),
- loc_xtra_init,
- loc_xtra_inject_data
-};
-
-static loc_gps_ni_notify_callback gps_ni_cb = NULL;
-static void local_ni_cb(LocGpsNiNotification *notification, bool esEnalbed);
-
-static GpsNiExtCallbacks sGpsNiExtCallbacks = {
- local_ni_cb
-};
-
-static void loc_ni_init(LocGpsNiCallbacks *callbacks);
-static void loc_ni_respond(int notif_id, LocGpsUserResponseType user_response);
-
-static const LocGpsNiInterface sLocEngNiInterface =
-{
- sizeof(LocGpsNiInterface),
- loc_ni_init,
- loc_ni_respond,
-};
-
-static int loc_gps_measurement_init(LocGpsMeasurementCallbacks* callbacks);
-static void loc_gps_measurement_close();
-
-static const LocGpsMeasurementInterface sLocEngGpsMeasurementInterface =
-{
- sizeof(LocGpsMeasurementInterface),
- loc_gps_measurement_init,
- loc_gps_measurement_close
-};
-
-static void loc_agps_ril_init( LocAGpsRilCallbacks* callbacks );
-static void loc_agps_ril_set_ref_location(const LocAGpsRefLocation *agps_reflocation, size_t sz_struct);
-static void loc_agps_ril_set_set_id(LocAGpsSetIDType type, const char* setid);
-static void loc_agps_ril_ni_message(uint8_t *msg, size_t len);
-static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info);
-static void loc_agps_ril_update_network_availability(int avaiable, const char* apn);
-
-static const LocAGpsRilInterface sLocEngAGpsRilInterface =
-{
- sizeof(LocAGpsRilInterface),
- loc_agps_ril_init,
- loc_agps_ril_set_ref_location,
- loc_agps_ril_set_set_id,
- loc_agps_ril_ni_message,
- loc_agps_ril_update_network_state,
- loc_agps_ril_update_network_availability
-};
-
-static int loc_agps_install_certificates(const LocDerEncodedCertificate* certificates,
- size_t length);
-static int loc_agps_revoke_certificates(const LocSha1CertificateFingerprint* fingerprints,
- size_t length);
-
-static const LocSuplCertificateInterface sLocEngAGpsCertInterface =
-{
- sizeof(LocSuplCertificateInterface),
- loc_agps_install_certificates,
- loc_agps_revoke_certificates
-};
-
-static void loc_configuration_update(const char* config_data, int32_t length);
-
-static const LocGnssConfigurationInterface sLocEngConfigInterface =
-{
- sizeof(LocGnssConfigurationInterface),
- loc_configuration_update
-};
-
-static loc_eng_data_s_type loc_afw_data;
-static int gss_fd = -1;
-static int sGnssType = GNSS_UNKNOWN;
-/*===========================================================================
-FUNCTION loc_eng_gps_get_hardware_interface
-
-DESCRIPTION
- Returns LocGpsInterface
- if GPS is enabled.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-extern "C" const LocGpsInterface* loc_eng_gps_get_hardware_interface ()
-{
- ENTRY_LOG_CALLFLOW();
- const LocGpsInterface* ret_val;
-
- char propBuf[PROPERTY_VALUE_MAX];
- memset(propBuf, 0, sizeof(propBuf));
-
- loc_eng_read_config();
-
- // check to see if GPS should be disabled
- platform_lib_abstraction_property_get("gps.disable", propBuf, "");
- if (propBuf[0] == '1')
- {
- LOC_LOGD("gps_get_interface returning NULL because gps.disable=1\n");
- ret_val = NULL;
- } else {
- ret_val = &sLocEngInterface;
- }
-
- loc_eng_read_config();
-
- EXIT_LOG(%p, ret_val);
- return ret_val;
-}
-
-extern "C" const LocGpsInterface* loc_eng_get_gps_interface()
-{
- unsigned int target = TARGET_DEFAULT;
- loc_eng_read_config();
-
- target = loc_get_target();
- LOC_LOGD("Target name check returned %s", loc_get_target_name(target));
-
- sGnssType = getTargetGnssType(target);
- switch (sGnssType)
- {
- case GNSS_GSS:
- case GNSS_AUTO:
- //APQ8064
- gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB);
- gss_fd = open("/dev/gss", O_RDONLY);
- if (gss_fd < 0) {
- LOC_LOGE("GSS open failed: %s\n", strerror(errno));
- }
- else {
- LOC_LOGD("GSS open success! CAPABILITIES %0lx\n",
- gps_conf.CAPABILITIES);
- }
- break;
- case GNSS_NONE:
- //MPQ8064
- LOC_LOGE("No GPS HW on this target. Not returning interface.");
- return NULL;
- case GNSS_QCA1530:
- // qca1530 chip is present
- gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB);
- LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES);
- break;
- }
- return &sLocEngInterface;
-}
-
-/*===========================================================================
-FUNCTION loc_init
-
-DESCRIPTION
- Initialize the location engine, this include setting up global datas
- and registers location engien with loc api service.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/Ax
-
-===========================================================================*/
-static int loc_init(LocGpsCallbacks* callbacks)
-{
- int retVal = -1;
- unsigned int target = (unsigned int) -1;
- ENTRY_LOG();
- LOC_API_ADAPTER_EVENT_MASK_T event;
-
- if (NULL == callbacks) {
- LOC_LOGE("loc_init failed. cb = NULL\n");
- EXIT_LOG(%d, retVal);
- return retVal;
- }
-
- event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT |
- LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT |
- LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
- LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST |
- LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST |
- LOC_API_ADAPTER_BIT_IOCTL_REPORT |
- LOC_API_ADAPTER_BIT_STATUS_REPORT |
- LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
- LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
-
- target = loc_get_target();
-
- /* If platform is "auto" and external dr enabled then enable
- ** Measurement report and SV Polynomial report
- */
- if((1 == gps_conf.EXTERNAL_DR_ENABLED))
- {
- event |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT |
- LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT;
- }
-
- LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */
- callbacks->status_cb, /* status_cb */
- local_sv_cb, /* sv_status_cb */
- callbacks->nmea_cb, /* nmea_cb */
- callbacks->set_capabilities_cb, /* set_capabilities_cb */
- callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */
- callbacks->release_wakelock_cb, /* release_wakelock_cb */
- callbacks->create_thread_cb, /* create_thread_cb */
- NULL, /* location_ext_parser */
- NULL, /* sv_ext_parser */
- callbacks->request_utc_time_cb, /* request_utc_time_cb */
- callbacks->set_system_info_cb, /* set_system_info_cb */
- callbacks->gnss_sv_status_cb, /* gnss_sv_status_cb */
- };
-
- gps_loc_cb = callbacks->location_cb;
- gps_sv_cb = callbacks->sv_status_cb;
-
- retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL);
- loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities();
- loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities();
- loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities()
- && !loc_afw_data.adapter->hasNativeXtraClient();
- loc_afw_data.adapter->setGpsLockMsg(0);
- loc_afw_data.adapter->requestUlp(ContextBase::getCarrierCapabilities());
- loc_afw_data.adapter->setXtraUserAgent();
-
- if(retVal) {
- LOC_LOGE("loc_eng_init() fail!");
- goto err;
- }
-
- loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530);
- loc_afw_data.adapter->setPowerVote(true);
-
- LOC_LOGD("loc_eng_init() success!");
-
-err:
- EXIT_LOG(%d, retVal);
- return retVal;
-}
-
-/*===========================================================================
-FUNCTION loc_cleanup
-
-DESCRIPTION
- Cleans location engine. The location client handle will be released.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_cleanup()
-{
- ENTRY_LOG();
-
- loc_afw_data.adapter->setPowerVote(false);
- loc_afw_data.adapter->setGpsLockMsg(gps_conf.GPS_LOCK);
-
- loc_eng_cleanup(loc_afw_data);
- gps_loc_cb = NULL;
- gps_sv_cb = NULL;
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_start
-
-DESCRIPTION
- Starts the tracking session
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_start()
-{
- ENTRY_LOG();
- int ret_val = loc_eng_start(loc_afw_data);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_stop
-
-DESCRIPTION
- Stops the tracking session
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_stop()
-{
- ENTRY_LOG();
- int ret_val = -1;
- ret_val = loc_eng_stop(loc_afw_data);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_set_position_mode
-
-DESCRIPTION
- Sets the mode and fix frequency for the tracking session.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_set_position_mode(LocGpsPositionMode mode,
- LocGpsPositionRecurrence recurrence,
- uint32_t min_interval,
- uint32_t preferred_accuracy,
- uint32_t preferred_time)
-{
- ENTRY_LOG();
- int ret_val = -1;
- LocPositionMode locMode;
- switch (mode) {
- case LOC_GPS_POSITION_MODE_MS_BASED:
- locMode = LOC_POSITION_MODE_MS_BASED;
- break;
- case LOC_GPS_POSITION_MODE_MS_ASSISTED:
- locMode = LOC_POSITION_MODE_MS_ASSISTED;
- break;
- default:
- locMode = LOC_POSITION_MODE_STANDALONE;
- break;
- }
-
- // set position sharing option to true
- bool sharePosition = true;
-
- LocPosMode params(locMode, recurrence, min_interval,
- preferred_accuracy, preferred_time,
- sharePosition, NULL, NULL);
- ret_val = loc_eng_set_position_mode(loc_afw_data, params);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_inject_time
-
-DESCRIPTION
- This is used by Java native function to do time injection.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_inject_time(LocGpsUtcTime time, int64_t timeReference, int uncertainty)
-{
- ENTRY_LOG();
- int ret_val = 0;
-
- ret_val = loc_eng_inject_time(loc_afw_data, time,
- timeReference, uncertainty);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-
-/*===========================================================================
-FUNCTION loc_inject_location
-
-DESCRIPTION
- This is used by Java native function to do location injection.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0 : Successful
- error code : Failure
-
-SIDE EFFECTS
- N/A
-===========================================================================*/
-static int loc_inject_location(double latitude, double longitude, float accuracy)
-{
- ENTRY_LOG();
-
- int ret_val = 0;
- ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-
-/*===========================================================================
-FUNCTION loc_delete_aiding_data
-
-DESCRIPTION
- This is used by Java native function to delete the aiding data. The function
- updates the global variable for the aiding data to be deleted. If the GPS
- engine is off, the aiding data will be deleted. Otherwise, the actual action
- will happen when gps engine is turned off.
-
-DEPENDENCIES
- Assumes the aiding data type specified in LocGpsAidingData matches with
- LOC API specification.
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_delete_aiding_data(LocGpsAidingData f)
-{
- ENTRY_LOG();
-
-#ifndef TARGET_BUILD_VARIANT_USER
- loc_eng_delete_aiding_data(loc_afw_data, f);
-#endif
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-static const LocGpsGeofencingInterface* get_geofence_interface(void)
-{
- ENTRY_LOG();
- void *handle;
- const char *error;
- typedef const LocGpsGeofencingInterface* (*get_gps_geofence_interface_function) (void);
- get_gps_geofence_interface_function get_gps_geofence_interface;
- static const LocGpsGeofencingInterface* geofence_interface = NULL;
-
- dlerror(); /* Clear any existing error */
-
- handle = dlopen ("libgeofence.so", RTLD_NOW);
-
- if (!handle)
- {
- if ((error = dlerror()) != NULL) {
- LOC_LOGE ("%s, dlopen for libgeofence.so failed, error = %s\n", __func__, error);
- }
- goto exit;
- }
- dlerror(); /* Clear any existing error */
- get_gps_geofence_interface = (get_gps_geofence_interface_function)dlsym(handle, "loc_gps_geofence_get_interface");
- if ((error = dlerror()) != NULL) {
- LOC_LOGE ("%s, dlsym for get_gps_geofence_interface failed, error = %s\n", __func__, error);
- goto exit;
- }
- if (NULL == get_gps_geofence_interface) {
- LOC_LOGE ("%s, get_gps_geofence_interface is NULL\n", __func__);
- goto exit;
- }
-
- geofence_interface = get_gps_geofence_interface();
-
-exit:
- EXIT_LOG(%d, geofence_interface == NULL);
- return geofence_interface;
-}
-/*===========================================================================
-FUNCTION loc_get_extension
-
-DESCRIPTION
- Get the gps extension to support XTRA.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- The GPS extension interface.
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-const void* loc_get_extension(const char* name)
-{
- ENTRY_LOG();
- const void* ret_val = NULL;
-
- LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name);
- if (strcmp(name, LOC_GPS_XTRA_INTERFACE) == 0)
- {
- ret_val = &sLocEngXTRAInterface;
- }
- else if (strcmp(name, LOC_AGPS_INTERFACE) == 0)
- {
- ret_val = &sLocEngAGpsInterface;
- }
- else if (strcmp(name, LOC_GPS_NI_INTERFACE) == 0)
- {
- ret_val = &sLocEngNiInterface;
- }
- else if (strcmp(name, LOC_AGPS_RIL_INTERFACE) == 0)
- {
- char baseband[PROPERTY_VALUE_MAX];
- platform_lib_abstraction_property_get("ro.baseband", baseband, "msm");
- if (strcmp(baseband, "csfb") == 0)
- {
- ret_val = &sLocEngAGpsRilInterface;
- }
- }
- else if (strcmp(name, LOC_GPS_GEOFENCING_INTERFACE) == 0)
- {
- if ((gps_conf.CAPABILITIES | LOC_GPS_CAPABILITY_GEOFENCING) == gps_conf.CAPABILITIES ){
- ret_val = get_geofence_interface();
- }
- }
- else if (strcmp(name, LOC_SUPL_CERTIFICATE_INTERFACE) == 0)
- {
- ret_val = &sLocEngAGpsCertInterface;
- }
- else if (strcmp(name, LOC_GNSS_CONFIGURATION_INTERFACE) == 0)
- {
- ret_val = &sLocEngConfigInterface;
- }
- else if (strcmp(name, LOC_GPS_MEASUREMENT_INTERFACE) == 0)
- {
- ret_val = &sLocEngGpsMeasurementInterface;
- }
- else
- {
- LOC_LOGE ("get_extension: Invalid interface passed in\n");
- }
- EXIT_LOG(%p, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_agps_init
-
-DESCRIPTION
- Initialize the AGps interface.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_agps_init(LocAGpsCallbacks* callbacks)
-{
- ENTRY_LOG();
- loc_eng_agps_init(loc_afw_data, (AGpsExtCallbacks*)callbacks);
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_agps_open
-
-DESCRIPTION
- This function is called when on-demand data connection opening is successful.
-It should inform ARM 9 about the data open result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_agps_open(const char* apn)
-{
- ENTRY_LOG();
- LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL;
- AGpsBearerType bearerType = AGPS_APN_BEARER_IPV4;
- int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_agps_open_with_apniptype
-
-DESCRIPTION
- This function is called when on-demand data connection opening is successful.
-It should inform ARM 9 about the data open result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_agps_open_with_apniptype(const char* apn, LocApnIpType apnIpType)
-{
- ENTRY_LOG();
- LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL;
- AGpsBearerType bearerType;
-
- switch (apnIpType) {
- case LOC_APN_IP_IPV4:
- bearerType = AGPS_APN_BEARER_IPV4;
- break;
- case LOC_APN_IP_IPV6:
- bearerType = AGPS_APN_BEARER_IPV6;
- break;
- case LOC_APN_IP_IPV4V6:
- bearerType = AGPS_APN_BEARER_IPV4V6;
- break;
- default:
- bearerType = AGPS_APN_BEARER_IPV4;
- break;
- }
-
- int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_agps_closed
-
-DESCRIPTION
- This function is called when on-demand data connection closing is done.
-It should inform ARM 9 about the data close result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_agps_closed()
-{
- ENTRY_LOG();
- LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL;
- int ret_val = loc_eng_agps_closed(loc_afw_data, agpsType);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_agps_open_failed
-
-DESCRIPTION
- This function is called when on-demand data connection opening has failed.
-It should inform ARM 9 about the data open result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_agps_open_failed()
-{
- ENTRY_LOG();
- LocAGpsType agpsType = LOC_AGPS_TYPE_SUPL;
- int ret_val = loc_eng_agps_open_failed(loc_afw_data, agpsType);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_agps_set_server
-
-DESCRIPTION
- If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
- proxy buffers server settings and calls loc_eng_set_server when the client is
- open.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_agps_set_server(LocAGpsType type, const char* hostname, int port)
-{
- ENTRY_LOG();
- LocServerType serverType;
- switch (type) {
- case LOC_AGPS_TYPE_SUPL:
- serverType = LOC_AGPS_SUPL_SERVER;
- break;
- case LOC_AGPS_TYPE_C2K:
- serverType = LOC_AGPS_CDMA_PDE_SERVER;
- break;
- default:
- serverType = LOC_AGPS_SUPL_SERVER;
- }
- int ret_val = loc_eng_set_server_proxy(loc_afw_data, serverType, hostname, port);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTIONf571
- loc_xtra_init
-
-DESCRIPTION
- Initialize XTRA module.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_xtra_init(LocGpsXtraCallbacks* callbacks)
-{
- ENTRY_LOG();
- GpsXtraExtCallbacks extCallbacks;
- memset(&extCallbacks, 0, sizeof(extCallbacks));
- extCallbacks.download_request_cb = callbacks->download_request_cb;
- int ret_val = loc_eng_xtra_init(loc_afw_data, &extCallbacks);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-
-/*===========================================================================
-FUNCTION loc_xtra_inject_data
-
-DESCRIPTION
- Initialize XTRA module.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_xtra_inject_data(char* data, int length)
-{
- ENTRY_LOG();
- int ret_val = -1;
- if( (data != NULL) && ((unsigned int)length <= XTRA_DATA_MAX_SIZE))
- ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length);
- else
- LOC_LOGE("%s, Could not inject XTRA data. Buffer address: %p, length: %d",
- __func__, data, length);
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_gps_measurement_init
-
-DESCRIPTION
- This function initializes the gps measurement interface
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_gps_measurement_init(LocGpsMeasurementCallbacks* callbacks)
-{
- ENTRY_LOG();
- int ret_val = loc_eng_gps_measurement_init(loc_afw_data,
- callbacks);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_gps_measurement_close
-
-DESCRIPTION
- This function closes the gps measurement interface
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_gps_measurement_close()
-{
- ENTRY_LOG();
- loc_eng_gps_measurement_close(loc_afw_data);
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_ni_init
-
-DESCRIPTION
- This function initializes the NI interface
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_ni_init(LocGpsNiCallbacks *callbacks)
-{
- ENTRY_LOG();
- gps_ni_cb = callbacks->notify_cb;
- loc_eng_ni_init(loc_afw_data, &sGpsNiExtCallbacks);
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_ni_respond
-
-DESCRIPTION
- This function sends an NI respond to the modem processor
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_ni_respond(int notif_id, LocGpsUserResponseType user_response)
-{
- ENTRY_LOG();
- loc_eng_ni_respond(loc_afw_data, notif_id, user_response);
- EXIT_LOG(%s, VOID_RET);
-}
-
-// Below stub functions are members of sLocEngAGpsRilInterface
-static void loc_agps_ril_init( LocAGpsRilCallbacks* callbacks ) {}
-static void loc_agps_ril_set_ref_location(const LocAGpsRefLocation *agps_reflocation, size_t sz_struct) {}
-static void loc_agps_ril_set_set_id(LocAGpsSetIDType type, const char* setid) {}
-static void loc_agps_ril_ni_message(uint8_t *msg, size_t len) {}
-static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info) {}
-
-/*===========================================================================
-FUNCTION loc_agps_ril_update_network_availability
-
-DESCRIPTION
- Sets data call allow vs disallow flag to modem
- This is the only member of sLocEngAGpsRilInterface implemented.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_agps_ril_update_network_availability(int available, const char* apn)
-{
- ENTRY_LOG();
- loc_eng_agps_ril_update_network_availability(loc_afw_data, available, apn);
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_agps_install_certificates(const LocDerEncodedCertificate* certificates,
- size_t length)
-{
- ENTRY_LOG();
- int ret_val = loc_eng_agps_install_certificates(loc_afw_data, certificates, length);
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-static int loc_agps_revoke_certificates(const LocSha1CertificateFingerprint* fingerprints,
- size_t length)
-{
- ENTRY_LOG();
- LOC_LOGE("%s:%d] agps_revoke_certificates not supported", __func__, __LINE__);
- int ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC;
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-static void loc_configuration_update(const char* config_data, int32_t length)
-{
- ENTRY_LOG();
- loc_eng_configuration_update(loc_afw_data, config_data, length);
- switch (sGnssType)
- {
- case GNSS_GSS:
- case GNSS_AUTO:
- case GNSS_QCA1530:
- //APQ
- gps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB);
- break;
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_loc_cb(UlpLocation* location, void* locExt)
-{
- ENTRY_LOG();
- if (NULL != location) {
- CALLBACK_LOG_CALLFLOW("location_cb - from", %d, location->position_source);
-
- if (NULL != gps_loc_cb) {
- gps_loc_cb(&location->gpsLocation);
- }
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_sv_cb(LocGpsSvStatus* sv_status, void* svExt)
-{
- ENTRY_LOG();
- if (NULL != gps_sv_cb) {
- CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs);
- gps_sv_cb(sv_status);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void local_ni_cb(LocGpsNiNotification *notification, bool esEnalbed)
-{
- if (NULL != gps_ni_cb) {
- gps_ni_cb(notification);
- }
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc.h b/msm8998/loc_api/libloc_api_50001/loc.h
deleted file mode 100644
index 9edd8c0..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef __LOC_H__
-#define __LOC_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include <ctype.h>
-#include <gps_extended.h>
-
-#define XTRA_DATA_MAX_SIZE 100000 /*bytes*/
-
-typedef void (*loc_location_cb_ext) (UlpLocation* location, void* locExt);
-typedef void (*loc_sv_status_cb_ext) (LocGpsSvStatus* sv_status, void* svExt);
-typedef void* (*loc_ext_parser)(void* data);
-
-typedef struct {
- loc_location_cb_ext location_cb;
- loc_gps_status_callback status_cb;
- loc_sv_status_cb_ext sv_status_cb;
- loc_gps_nmea_callback nmea_cb;
- loc_gps_set_capabilities set_capabilities_cb;
- loc_gps_acquire_wakelock acquire_wakelock_cb;
- loc_gps_release_wakelock release_wakelock_cb;
- loc_gps_create_thread create_thread_cb;
- loc_ext_parser location_ext_parser;
- loc_ext_parser sv_ext_parser;
- loc_gps_request_utc_time request_utc_time_cb;
- loc_gnss_set_system_info set_system_info_cb;
- loc_gnss_sv_status_callback gnss_sv_status_cb;
-} LocCallbacks;
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif //__LOC_H__
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng.cpp
deleted file mode 100644
index 094c1c3..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng.cpp
+++ /dev/null
@@ -1,3122 +0,0 @@
-/* Copyright (c) 2009-2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng"
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <ctype.h>
-#include <math.h>
-#include <pthread.h>
-#include <arpa/inet.h>
-#include <netinet/in.h> /* struct sockaddr_in */
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <netdb.h>
-#include <time.h>
-#include <new>
-#include <LocEngAdapter.h>
-
-
-#include <string.h>
-#include <loc_eng.h>
-#include <loc_eng_ni.h>
-#include <loc_eng_dmn_conn.h>
-#include <loc_eng_dmn_conn_handler.h>
-#include <loc_eng_msg.h>
-#include <loc_eng_nmea.h>
-#include <msg_q.h>
-#include <loc.h>
-#include <platform_lib_includes.h>
-#include "loc_core_log.h"
-#include "loc_eng_log.h"
-
-#define SUCCESS TRUE
-#define FAILURE FALSE
-
-#define XTRA1_GPSONEXTRA "xtra1.gpsonextra.net"
-
-using namespace loc_core;
-
-boolean configAlreadyRead = false;
-unsigned int agpsStatus = 0;
-
-/* Parameter spec table */
-static const loc_param_s_type gps_conf_table[] =
-{
- {"GPS_LOCK", &gps_conf.GPS_LOCK, NULL, 'n'},
- {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'},
- {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'},
- {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'},
- {"LPPE_CP_TECHNOLOGY", &gps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'},
- {"LPPE_UP_TECHNOLOGY", &gps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'},
- {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'},
- {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'},
- {"SUPL_ES", &gps_conf.SUPL_ES, NULL, 'n'},
- {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'},
- {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'},
- {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'},
- {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'},
- {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'},
- {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'},
- {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'},
- {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'},
- {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'},
- {"AGPS_CONFIG_INJECT", &gps_conf.AGPS_CONFIG_INJECT, NULL, 'n'},
- {"EXTERNAL_DR_ENABLED", &gps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'},
-};
-
-static const loc_param_s_type sap_conf_table[] =
-{
- {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'},
- {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
- {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
- {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
- {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'},
- {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'},
- {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'},
- {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'},
- {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'},
- {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'},
- {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
- {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'},
- {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'},
- {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'},
- {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'},
- {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'},
- {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'}
-};
-
-static void loc_default_parameters(void)
-{
- /*Defaults for gps.conf*/
- gps_conf.INTERMEDIATE_POS = 0;
- gps_conf.ACCURACY_THRES = 0;
- gps_conf.NMEA_PROVIDER = 0;
- gps_conf.GPS_LOCK = 0;
- gps_conf.SUPL_VER = 0x10000;
- gps_conf.SUPL_MODE = 0x1;
- gps_conf.SUPL_ES = 0;
- gps_conf.CAPABILITIES = 0x7;
- /* LTE Positioning Profile configuration is disable by default*/
- gps_conf.LPP_PROFILE = 0;
- /*By default no positioning protocol is selected on A-GLONASS system*/
- gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0;
- /*XTRA version check is disabled by default*/
- gps_conf.XTRA_VERSION_CHECK=0;
- /*Use emergency PDN by default*/
- gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1;
- /* By default no LPPe CP technology is enabled*/
- gps_conf.LPPE_CP_TECHNOLOGY = 0;
- /* By default no LPPe UP technology is enabled*/
- gps_conf.LPPE_UP_TECHNOLOGY = 0;
-
- /*Defaults for sap.conf*/
- sap_conf.GYRO_BIAS_RANDOM_WALK = 0;
- sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2;
- sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5;
- sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2;
- sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5;
- sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4;
- sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25;
- sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4;
- sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25;
- sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */
- sap_conf.SENSOR_USAGE = 0; /* Enabled */
- sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/
- /* Values MUST be set by OEMs in configuration for sensor-assisted
- navigation to work. There are NO default values */
- sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0;
- sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
- sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0;
- sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0;
- sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0;
- sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
- sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
- sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
- sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0;
- /* default provider is SSC */
- sap_conf.SENSOR_PROVIDER = 1;
-
- /* None of the 10 slots for agps certificates are writable by default */
- gps_conf.AGPS_CERT_WRITABLE_MASK = 0;
-
- /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */
- gps_conf.AGPS_CONFIG_INJECT = 1;
-}
-
-// 2nd half of init(), singled out for
-// modem restart to use.
-static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data);
-static void loc_eng_dsclient_release(loc_eng_data_s_type &loc_eng_data);
-static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data);
-
-static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
- LocServerType type, const char *hostname, int port);
-// Internal functions
-static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data,
- LocGpsStatusValue status);
-static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data,
- LocGpsStatusValue status);
-static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data,
- int connHandle, LocAGpsType agps_type);
-static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ);
-static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ;
-static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ;
-
-static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data);
-static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data);
-static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data);
-static void deleteAidingData(loc_eng_data_s_type &logEng);
-static AgpsStateMachine*
-getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType);
-static void createAgnssNifs(loc_eng_data_s_type& locEng);
-static int dataCallCb(void *cb_data);
-static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) {
- if (loc_eng_data.engine_status != LOC_GPS_STATUS_ENGINE_ON &&
- loc_eng_data.aiding_data_for_deletion != 0)
- {
- loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion);
- loc_eng_data.aiding_data_for_deletion = 0;
- }
-}
-
-static void* noProc(void* data)
-{
- return NULL;
-}
-
-/*********************************************************************
- * definitions of the static messages used in the file
- *********************************************************************/
-// case LOC_ENG_MSG_REQUEST_NI:
-LocEngRequestNi::LocEngRequestNi(void* locEng,
- LocGpsNiNotification ¬if,
- const void* data) :
- LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) {
- locallog();
-}
-void LocEngRequestNi::proc() const {
- loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng),
- &mNotify, mPayload);
-}
-void LocEngRequestNi::locallog() const
-{
- LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n "
- "default response: %s\n requestor id encoding: %s\n"
- " text encoding: %s\n passThroughData: %p",
- mNotify.notification_id,
- loc_get_ni_type_name(mNotify.ni_type),
- mNotify.notify_flags,
- mNotify.timeout,
- loc_get_ni_response_name(mNotify.default_response),
- loc_get_ni_encoding_name(mNotify.requestor_id_encoding),
- loc_get_ni_encoding_name(mNotify.text_encoding),
- mPayload);
-}
-inline void LocEngRequestNi::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_INFORM_NI_RESPONSE:
-// in loc_eng_ni.cpp
-
-// case LOC_ENG_MSG_START_FIX:
-LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter)
-{
- locallog();
-}
-inline void LocEngStartFix::proc() const
-{
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
- loc_eng_start_handler(*locEng);
-}
-inline void LocEngStartFix::locallog() const
-{
- LOC_LOGV("LocEngStartFix");
-}
-inline void LocEngStartFix::log() const
-{
- locallog();
-}
-void LocEngStartFix::send() const {
- mAdapter->sendMsg(this);
-}
-
-// case LOC_ENG_MSG_STOP_FIX:
-LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter)
-{
- locallog();
-}
-inline void LocEngStopFix::proc() const
-{
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
- mAdapter->clearGnssSvUsedListData();
- loc_eng_stop_handler(*locEng);
-}
-inline void LocEngStopFix::locallog() const
-{
- LOC_LOGV("LocEngStopFix");
-}
-inline void LocEngStopFix::log() const
-{
- locallog();
-}
-void LocEngStopFix::send() const {
- mAdapter->sendMsg(this);
-}
-
-// case LOC_ENG_MSG_SET_POSITION_MODE:
-LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter,
- LocPosMode &mode) :
- LocMsg(), mAdapter(adapter), mPosMode(mode)
-{
- mPosMode.logv();
-}
-inline void LocEngPositionMode::proc() const {
- mAdapter->setPositionMode(&mPosMode);
-}
-inline void LocEngPositionMode::log() const {
- mPosMode.logv();
-}
-void LocEngPositionMode::send() const {
- mAdapter->sendMsg(this);
-}
-
-LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter)
-{
- locallog();
-}
-inline void LocEngGetZpp::proc() const
-{
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner();
- loc_eng_get_zpp_handler(*locEng);
-}
-inline void LocEngGetZpp::locallog() const
-{
- LOC_LOGV("LocEngGetZpp");
-}
-inline void LocEngGetZpp::log() const
-{
- locallog();
-}
-void LocEngGetZpp::send() const {
- mAdapter->sendMsg(this);
-}
-
-struct LocEngSetTime : public LocMsg {
- LocEngAdapter* mAdapter;
- const LocGpsUtcTime mTime;
- const int64_t mTimeReference;
- const int mUncertainty;
- inline LocEngSetTime(LocEngAdapter* adapter,
- LocGpsUtcTime t, int64_t tf, int unc) :
- LocMsg(), mAdapter(adapter),
- mTime(t), mTimeReference(tf), mUncertainty(unc)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setTime(mTime, mTimeReference, mUncertainty);
- }
- inline void locallog() const {
- LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d",
- mTime, mTimeReference, mUncertainty);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
- // case LOC_ENG_MSG_INJECT_LOCATION:
-struct LocEngInjectLocation : public LocMsg {
- LocEngAdapter* mAdapter;
- const double mLatitude;
- const double mLongitude;
- const float mAccuracy;
- inline LocEngInjectLocation(LocEngAdapter* adapter,
- double lat, double lon, float accur) :
- LocMsg(), mAdapter(adapter),
- mLatitude(lat), mLongitude(lon), mAccuracy(accur)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy);
- }
- inline void locallog() const {
- LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f",
- mLatitude, mLongitude, mAccuracy);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_SERVER_IPV4:
-struct LocEngSetServerIpv4 : public LocMsg {
- LocEngAdapter* mAdapter;
- const unsigned int mNlAddr;
- const int mPort;
- const LocServerType mServerType;
- inline LocEngSetServerIpv4(LocEngAdapter* adapter,
- unsigned int ip,
- int port,
- LocServerType type) :
- LocMsg(), mAdapter(adapter),
- mNlAddr(ip), mPort(port), mServerType(type)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (gps_conf.AGPS_CONFIG_INJECT) {
- mAdapter->setServer(mNlAddr, mPort, mServerType);
- }
- }
- inline void locallog() const {
- LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s",
- mNlAddr, mPort, loc_get_server_type_name(mServerType));
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_SERVER_URL:
-struct LocEngSetServerUrl : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mLen;
- char* mUrl;
- inline LocEngSetServerUrl(LocEngAdapter* adapter,
- char* urlString,
- int url_len) :
- LocMsg(), mAdapter(adapter),
- mLen(url_len), mUrl(new char[mLen+1])
- {
- memcpy((void*)mUrl, (void*)urlString, url_len);
- mUrl[mLen] = 0;
- locallog();
- }
- inline ~LocEngSetServerUrl()
- {
- delete[] mUrl;
- }
- inline virtual void proc() const {
- if (gps_conf.AGPS_CONFIG_INJECT) {
- mAdapter->setServer(mUrl, mLen);
- }
- }
- inline void locallog() const {
- LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_A_GLONASS_PROTOCOL:
-struct LocEngAGlonassProtocol : public LocMsg {
- LocEngAdapter* mAdapter;
- const unsigned long mAGlonassProtocl;
- inline LocEngAGlonassProtocol(LocEngAdapter* adapter,
- unsigned long protocol) :
- LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (gps_conf.AGPS_CONFIG_INJECT) {
- mAdapter->setAGLONASSProtocol(mAGlonassProtocl);
- }
- }
- inline void locallog() const {
- LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-
-struct LocEngLPPeProtocol : public LocMsg {
- LocEngAdapter* mAdapter;
- const unsigned long mLPPeCP;
- const unsigned long mLPPeUP;
- inline LocEngLPPeProtocol(LocEngAdapter* adapter,
- unsigned long lppeCP, unsigned long lppeUP) :
- LocMsg(), mAdapter(adapter), mLPPeCP(lppeCP), mLPPeUP(lppeUP)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setLPPeProtocol(mLPPeCP, mLPPeUP);
- }
- inline void locallog() const {
- LOC_LOGV("LPPe CP: 0x%lx LPPe UP: 0x%1x", mLPPeCP, mLPPeUP);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-
-// case LOC_ENG_MSG_SUPL_VERSION:
-struct LocEngSuplVer : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mSuplVer;
- inline LocEngSuplVer(LocEngAdapter* adapter,
- int suplVer) :
- LocMsg(), mAdapter(adapter), mSuplVer(suplVer)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (gps_conf.AGPS_CONFIG_INJECT) {
- mAdapter->setSUPLVersion(mSuplVer);
- }
- }
- inline void locallog() const {
- LOC_LOGV("SUPL Version: %d", mSuplVer);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-struct LocEngSuplMode : public LocMsg {
- LocEngAdapter* mAdapter;
-
- inline LocEngSuplMode(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->getUlpProxy()->setCapabilities(ContextBase::getCarrierCapabilities());
- }
- inline void locallog() const {
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_NMEA_TYPE:
-struct LocEngSetNmeaTypes : public LocMsg {
- LocEngAdapter* mAdapter;
- uint32_t nmeaTypesMask;
- inline LocEngSetNmeaTypes(LocEngAdapter* adapter,
- uint32_t typesMask) :
- LocMsg(), mAdapter(adapter), nmeaTypesMask(typesMask)
- {
- locallog();
- }
- inline virtual void proc() const {
- // set the nmea types
- mAdapter->setNMEATypes(nmeaTypesMask);
- }
- inline void locallog() const
- {
- LOC_LOGV("LocEngSetNmeaTypes %u\n",nmeaTypesMask);
- }
- inline virtual void log() const
- {
- locallog();
- }
-};
-
-
-// case LOC_ENG_MSG_LPP_CONFIG:
-struct LocEngLppConfig : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mLppConfig;
- inline LocEngLppConfig(LocEngAdapter* adapter,
- int lppConfig) :
- LocMsg(), mAdapter(adapter), mLppConfig(lppConfig)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (gps_conf.AGPS_CONFIG_INJECT) {
- mAdapter->setLPPConfig(mLppConfig);
- }
- }
- inline void locallog() const {
- LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG:
-struct LocEngSensorControlConfig : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mSensorsDisabled;
- const int mSensorProvider;
- inline LocEngSensorControlConfig(LocEngAdapter* adapter,
- int sensorsDisabled, int sensorProvider) :
- LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled),
- mSensorProvider(sensorProvider)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d",
- mSensorsDisabled, mSensorProvider);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_SENSOR_PROPERTIES:
-struct LocEngSensorProperties : public LocMsg {
- LocEngAdapter* mAdapter;
- const bool mGyroBiasVarianceRandomWalkValid;
- const float mGyroBiasVarianceRandomWalk;
- const bool mAccelRandomWalkValid;
- const float mAccelRandomWalk;
- const bool mAngleRandomWalkValid;
- const float mAngleRandomWalk;
- const bool mRateRandomWalkValid;
- const float mRateRandomWalk;
- const bool mVelocityRandomWalkValid;
- const float mVelocityRandomWalk;
- inline LocEngSensorProperties(LocEngAdapter* adapter,
- bool gyroBiasRandomWalk_valid,
- float gyroBiasRandomWalk,
- bool accelRandomWalk_valid,
- float accelRandomWalk,
- bool angleRandomWalk_valid,
- float angleRandomWalk,
- bool rateRandomWalk_valid,
- float rateRandomWalk,
- bool velocityRandomWalk_valid,
- float velocityRandomWalk) :
- LocMsg(), mAdapter(adapter),
- mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid),
- mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk),
- mAccelRandomWalkValid(accelRandomWalk_valid),
- mAccelRandomWalk(accelRandomWalk),
- mAngleRandomWalkValid(angleRandomWalk_valid),
- mAngleRandomWalk(angleRandomWalk),
- mRateRandomWalkValid(rateRandomWalk_valid),
- mRateRandomWalk(rateRandomWalk),
- mVelocityRandomWalkValid(velocityRandomWalk_valid),
- mVelocityRandomWalk(velocityRandomWalk)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid,
- mGyroBiasVarianceRandomWalk,
- mAccelRandomWalkValid,
- mAccelRandomWalk,
- mAngleRandomWalkValid,
- mAngleRandomWalk,
- mRateRandomWalkValid,
- mRateRandomWalk,
- mVelocityRandomWalkValid,
- mVelocityRandomWalk);
- }
- inline void locallog() const {
- LOC_LOGV("Sensor properties validity, Gyro Random walk: %d "
- "Accel Random Walk: %d "
- "Angle Random Walk: %d Rate Random Walk: %d "
- "Velocity Random Walk: %d\n"
- "Sensor properties, Gyro Random walk: %f "
- "Accel Random Walk: %f "
- "Angle Random Walk: %f Rate Random Walk: %f "
- "Velocity Random Walk: %f",
- mGyroBiasVarianceRandomWalkValid,
- mAccelRandomWalkValid,
- mAngleRandomWalkValid,
- mRateRandomWalkValid,
- mVelocityRandomWalkValid,
- mGyroBiasVarianceRandomWalk,
- mAccelRandomWalk,
- mAngleRandomWalk,
- mRateRandomWalk,
- mVelocityRandomWalk
- );
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG:
-struct LocEngSensorPerfControlConfig : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mControlMode;
- const int mAccelSamplesPerBatch;
- const int mAccelBatchesPerSec;
- const int mGyroSamplesPerBatch;
- const int mGyroBatchesPerSec;
- const int mAccelSamplesPerBatchHigh;
- const int mAccelBatchesPerSecHigh;
- const int mGyroSamplesPerBatchHigh;
- const int mGyroBatchesPerSecHigh;
- const int mAlgorithmConfig;
- inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter,
- int controlMode,
- int accelSamplesPerBatch,
- int accelBatchesPerSec,
- int gyroSamplesPerBatch,
- int gyroBatchesPerSec,
- int accelSamplesPerBatchHigh,
- int accelBatchesPerSecHigh,
- int gyroSamplesPerBatchHigh,
- int gyroBatchesPerSecHigh,
- int algorithmConfig) :
- LocMsg(), mAdapter(adapter),
- mControlMode(controlMode),
- mAccelSamplesPerBatch(accelSamplesPerBatch),
- mAccelBatchesPerSec(accelBatchesPerSec),
- mGyroSamplesPerBatch(gyroSamplesPerBatch),
- mGyroBatchesPerSec(gyroBatchesPerSec),
- mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh),
- mAccelBatchesPerSecHigh(accelBatchesPerSecHigh),
- mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh),
- mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh),
- mAlgorithmConfig(algorithmConfig)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->setSensorPerfControlConfig(mControlMode,
- mAccelSamplesPerBatch,
- mAccelBatchesPerSec,
- mGyroSamplesPerBatch,
- mGyroBatchesPerSec,
- mAccelSamplesPerBatchHigh,
- mAccelBatchesPerSecHigh,
- mGyroSamplesPerBatchHigh,
- mGyroBatchesPerSecHigh,
- mAlgorithmConfig);
- }
- inline void locallog() const {
- LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) "
- "accel(#smp,#batches) (%u,%u) "
- "gyro(#smp,#batches) (%u,%u), "
- "accel_high(#smp,#batches) (%u,%u) "
- "gyro_high(#smp,#batches) (%u,%u), "
- "algorithmConfig(%u)\n",
- mControlMode,
- mAccelSamplesPerBatch, mAccelBatchesPerSec,
- mGyroSamplesPerBatch, mGyroBatchesPerSec,
- mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh,
- mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh,
- mAlgorithmConfig);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_REPORT_POSITION:
-LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter,
- UlpLocation &loc,
- GpsLocationExtended &locExtended,
- void* locExt,
- enum loc_sess_status st,
- LocPosTechMask technology) :
- LocMsg(), mAdapter(adapter), mLocation(loc),
- mLocationExtended(locExtended),
- mLocationExt(((loc_eng_data_s_type*)
- ((LocEngAdapter*)
- (mAdapter))->getOwner())->location_ext_parser(locExt)),
- mStatus(st), mTechMask(technology)
-{
- locallog();
-}
-void LocEngReportPosition::proc() const {
- LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
-
- if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) {
- bool reported = false;
- if (locEng->location_cb != NULL) {
- if (LOC_SESS_FAILURE == mStatus) {
- // in case we want to handle the failure case
- locEng->location_cb(NULL, NULL);
- reported = true;
- }
- // what's in the else if is... (line by line)
- // 1. this is a final fix; and
- // 1.1 it is a Satellite fix; or
- // 1.2 it is a sensor fix
- // 2. (must be intermediate fix... implicit)
- // 2.1 we accepte intermediate; and
- // 2.2 it is NOT the case that
- // 2.2.1 there is inaccuracy; and
- // 2.2.2 we care about inaccuracy; and
- // 2.2.3 the inaccuracy exceeds our tolerance
- else if ((LOC_SESS_SUCCESS == mStatus &&
- ((LOC_POS_TECH_MASK_SATELLITE |
- LOC_POS_TECH_MASK_SENSORS |
- LOC_POS_TECH_MASK_HYBRID) &
- mTechMask)) ||
- (LOC_SESS_INTERMEDIATE == locEng->intermediateFix &&
- !((mLocation.gpsLocation.flags &
- LOC_GPS_LOCATION_HAS_ACCURACY) &&
- (gps_conf.ACCURACY_THRES != 0) &&
- (mLocation.gpsLocation.accuracy >
- gps_conf.ACCURACY_THRES)))) {
- if (mLocationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA)
- {
- adapter->setGnssSvUsedListData(mLocationExtended.gnss_sv_used_ids);
- }
- locEng->location_cb((UlpLocation*)&(mLocation),
- (void*)mLocationExt);
- reported = true;
- }
- }
-
- // if we have reported this fix
- if (reported &&
- // and if this is a singleshot
- LOC_GPS_POSITION_RECURRENCE_SINGLE ==
- locEng->adapter->getPositionMode().recurrence) {
- if (LOC_SESS_INTERMEDIATE == mStatus) {
- // modem could be still working for a final fix,
- // although we no longer need it. So stopFix().
- locEng->adapter->stopFix();
- }
- // turn off the session flag.
- locEng->adapter->setInSession(false);
- }
-
- LOC_LOGV("LocEngReportPosition::proc() - generateNmea: %d, position source: %d, "
- "engine_status: %d, isInSession: %d",
- locEng->generateNmea, mLocation.position_source,
- locEng->engine_status, locEng->adapter->isInSession());
-
- if (locEng->generateNmea &&
- locEng->adapter->isInSession())
- {
- unsigned char generate_nmea = reported &&
- (mStatus != LOC_SESS_FAILURE);
- loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended,
- generate_nmea);
- }
-
- // Free the allocated memory for rawData
- UlpLocation* gp = (UlpLocation*)&(mLocation);
- if (gp != NULL && gp->rawData != NULL)
- {
- delete (char*)gp->rawData;
- gp->rawData = NULL;
- gp->rawDataSize = 0;
- }
- }
-}
-void LocEngReportPosition::locallog() const {
- LOC_LOGV("LocEngReportPosition");
-}
-void LocEngReportPosition::log() const {
- locallog();
-}
-void LocEngReportPosition::send() const {
- mAdapter->sendMsg(this);
-}
-
-
-// case LOC_ENG_MSG_REPORT_SV:
-LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter,
- LocGnssSvStatus &sv,
- GpsLocationExtended &locExtended,
- void* svExt) :
- LocMsg(), mAdapter(adapter), mSvStatus(sv),
- mLocationExtended(locExtended),
- mSvExt(((loc_eng_data_s_type*)
- ((LocEngAdapter*)
- (mAdapter))->getOwner())->sv_ext_parser(svExt))
-{
- locallog();
-}
-void LocEngReportSv::proc() const {
- LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
-
- if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
- {
- LocGnssSvStatus gnssSvStatus;
- memcpy(&gnssSvStatus,&mSvStatus,sizeof(LocGnssSvStatus));
- if (adapter->isGnssSvIdUsedInPosAvail())
- {
- GnssSvUsedInPosition gnssSvIdUsedInPosition =
- adapter->getGnssSvUsedListData();
- int numSv = gnssSvStatus.num_svs;
- int16_t gnssSvId = 0;
- uint64_t svUsedIdMask = 0;
- for (int i=0; i < numSv; i++)
- {
- gnssSvId = gnssSvStatus.gnss_sv_list[i].svid;
- switch(gnssSvStatus.gnss_sv_list[i].constellation) {
- case LOC_GNSS_CONSTELLATION_GPS:
- svUsedIdMask = gnssSvIdUsedInPosition.gps_sv_used_ids_mask;
- break;
- case LOC_GNSS_CONSTELLATION_GLONASS:
- svUsedIdMask = gnssSvIdUsedInPosition.glo_sv_used_ids_mask;
- break;
- case LOC_GNSS_CONSTELLATION_BEIDOU:
- svUsedIdMask = gnssSvIdUsedInPosition.bds_sv_used_ids_mask;
- break;
- case LOC_GNSS_CONSTELLATION_GALILEO:
- svUsedIdMask = gnssSvIdUsedInPosition.gal_sv_used_ids_mask;
- break;
- default:
- svUsedIdMask = 0;
- break;
- }
-
- // If SV ID was used in previous position fix, then set USED_IN_FIX
- // flag, else clear the USED_IN_FIX flag.
- if (svUsedIdMask & (1 << (gnssSvId - 1)))
- {
- gnssSvStatus.gnss_sv_list[i].flags |= LOC_GNSS_SV_FLAGS_USED_IN_FIX;
- }
- else
- {
- gnssSvStatus.gnss_sv_list[i].flags &= ~LOC_GNSS_SV_FLAGS_USED_IN_FIX;
- }
- }
- }
-
- if (locEng->gnss_sv_status_cb != NULL) {
- LOC_LOGE("Calling gnss_sv_status_cb");
- locEng->gnss_sv_status_cb((LocGnssSvStatus*)&(gnssSvStatus));
- }
-
- if (locEng->generateNmea)
- {
- loc_eng_nmea_generate_sv(locEng, gnssSvStatus, mLocationExtended);
- }
- }
-}
-void LocEngReportSv::locallog() const {
- LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__);
-}
-inline void LocEngReportSv::log() const {
- locallog();
-}
-void LocEngReportSv::send() const {
- mAdapter->sendMsg(this);
-}
-
-// case LOC_ENG_MSG_REPORT_STATUS:
-LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter,
- LocGpsStatusValue engineStatus) :
- LocMsg(), mAdapter(adapter), mStatus(engineStatus)
-{
- locallog();
-}
-inline void LocEngReportStatus::proc() const
-{
- LocEngAdapter* adapter = (LocEngAdapter*)mAdapter;
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner();
-
- loc_eng_report_status(*locEng, mStatus);
- update_aiding_data_for_deletion(*locEng);
-}
-inline void LocEngReportStatus::locallog() const {
- LOC_LOGV("LocEngReportStatus");
-}
-inline void LocEngReportStatus::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REPORT_NMEA:
-LocEngReportNmea::LocEngReportNmea(void* locEng,
- const char* data, int len) :
- LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len)
-{
- memcpy((void*)mNmea, (void*)data, len);
- locallog();
-}
-void LocEngReportNmea::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
-
- struct timeval tv;
- gettimeofday(&tv, (struct timezone *) NULL);
- int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-
- if (locEng->nmea_cb != NULL)
- locEng->nmea_cb(now, mNmea, mLen);
-}
-inline void LocEngReportNmea::locallog() const {
- LOC_LOGV("LocEngReportNmea");
-}
-inline void LocEngReportNmea::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REPORT_XTRA_SERVER:
-LocEngReportXtraServer::LocEngReportXtraServer(void* locEng,
- const char *url1,
- const char *url2,
- const char *url3,
- const int maxlength) :
- LocMsg(), mLocEng(locEng), mMaxLen(maxlength),
- mServers(new char[3*(mMaxLen+1)])
-{
- char * cptr = mServers;
- memset(mServers, 0, 3*(mMaxLen+1));
-
- // Override modem URLs with uncommented gps.conf urls
- if( gps_conf.XTRA_SERVER_1[0] != '\0' ) {
- url1 = &gps_conf.XTRA_SERVER_1[0];
- }
- if( gps_conf.XTRA_SERVER_2[0] != '\0' ) {
- url2 = &gps_conf.XTRA_SERVER_2[0];
- }
- if( gps_conf.XTRA_SERVER_3[0] != '\0' ) {
- url3 = &gps_conf.XTRA_SERVER_3[0];
- }
- // copy non xtra1.gpsonextra.net URLs into the forwarding buffer.
- if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) {
- strlcpy(cptr, url1, mMaxLen + 1);
- cptr += mMaxLen + 1;
- }
- if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) {
- strlcpy(cptr, url2, mMaxLen + 1);
- cptr += mMaxLen + 1;
- }
- if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) {
- strlcpy(cptr, url3, mMaxLen + 1);
- }
- locallog();
-}
-
-void LocEngReportXtraServer::proc() const {
- loc_eng_xtra_data_s_type* locEngXtra =
- &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
-
- if (locEngXtra->report_xtra_server_cb != NULL) {
- CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers);
- locEngXtra->report_xtra_server_cb(mServers,
- &(mServers[mMaxLen+1]),
- &(mServers[(mMaxLen+1)<<1]));
- } else {
- LOC_LOGE("Callback function for request xtra is NULL");
- }
-}
-inline void LocEngReportXtraServer::locallog() const {
- LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n"
- " server3: %s\n",
- mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]);
-}
-inline void LocEngReportXtraServer::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REQUEST_BIT:
-// case LOC_ENG_MSG_RELEASE_BIT:
-LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type,
- int ipv4, char* ipv6, bool isReq) :
- LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4),
- mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) {
- if (NULL != ipv6)
- memcpy(mIPv6Addr, ipv6, 16);
- locallog();
-}
-inline LocEngReqRelBIT::~LocEngReqRelBIT() {
- if (mIPv6Addr) {
- delete[] mIPv6Addr;
- }
-}
-void LocEngReqRelBIT::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- BITSubscriber s(getAgpsStateMachine(*locEng, mType),
- mIPv4Addr, mIPv6Addr);
- AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine;
-
- if (mIsReq) {
- sm->subscribeRsrc((Subscriber*)&s);
- } else {
- sm->unsubscribeRsrc((Subscriber*)&s);
- }
-}
-inline void LocEngReqRelBIT::locallog() const {
- LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
- (unsigned char)mIPv4Addr,
- (unsigned char)(mIPv4Addr>>8),
- (unsigned char)(mIPv4Addr>>16),
- (unsigned char)(mIPv4Addr>>24),
- NULL != mIPv6Addr ? mIPv6Addr : "");
-}
-inline void LocEngReqRelBIT::log() const {
- locallog();
-}
-void LocEngReqRelBIT::send() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- locEng->adapter->sendMsg(this);
-}
-
-// case LOC_ENG_MSG_RELEASE_BIT:
-struct LocEngReleaseBIT : public LocMsg {
- const BITSubscriber mSubscriber;
- inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine,
- unsigned int ipv4, char* ipv6) :
- LocMsg(),
- mSubscriber(stateMachine, ipv4, ipv6)
- {
- locallog();
- }
- inline virtual void proc() const
- {
- AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine;
- sm->unsubscribeRsrc((Subscriber*)&mSubscriber);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s",
- (unsigned char)(mSubscriber.ID>>24),
- (unsigned char)(mSubscriber.ID>>16),
- (unsigned char)(mSubscriber.ID>>8),
- (unsigned char)mSubscriber.ID,
- NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : "");
- }
- virtual void log() const {
- locallog();
- }
-};
-
-// LocEngSuplEsOpened
-LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) :
- LocMsg(), mLocEng(locEng) {
- locallog();
-}
-void LocEngSuplEsOpened::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- if (locEng->ds_nif) {
- AgpsStateMachine* sm = locEng->ds_nif;
- sm->onRsrcEvent(RSRC_GRANTED);
- }
-}
-void LocEngSuplEsOpened::locallog() const {
- LOC_LOGV("LocEngSuplEsOpened");
-}
-void LocEngSuplEsOpened::log() const {
- locallog();
-}
-
-// LocEngSuplEsClosed
-LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) :
- LocMsg(), mLocEng(locEng) {
- locallog();
-}
-void LocEngSuplEsClosed::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- if (locEng->ds_nif) {
- AgpsStateMachine* sm = locEng->ds_nif;
- sm->onRsrcEvent(RSRC_RELEASED);
- }
-}
-void LocEngSuplEsClosed::locallog() const {
- LOC_LOGV("LocEngSuplEsClosed");
-}
-void LocEngSuplEsClosed::log() const {
- locallog();
-}
-
-
-// case LOC_ENG_MSG_REQUEST_SUPL_ES:
-LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) :
- LocMsg(), mLocEng(locEng), mID(id) {
- locallog();
-}
-void LocEngRequestSuplEs::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
- AgpsStateMachine* sm = locEng->ds_nif;
- DSSubscriber s(sm, mID);
- sm->subscribeRsrc((Subscriber*)&s);
- }
- else if (locEng->agnss_nif) {
- AgpsStateMachine *sm = locEng->agnss_nif;
- ATLSubscriber s(mID,
- sm,
- locEng->adapter,
- false);
- sm->subscribeRsrc((Subscriber*)&s);
- LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__);
- }
- else {
- locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1);
- }
-}
-inline void LocEngRequestSuplEs::locallog() const {
- LOC_LOGV("LocEngRequestSuplEs");
-}
-inline void LocEngRequestSuplEs::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REQUEST_ATL:
-LocEngRequestATL::LocEngRequestATL(void* locEng, int id,
- AGpsExtType agps_type) :
- LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) {
- locallog();
-}
-void LocEngRequestATL::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- AgpsStateMachine* sm = (AgpsStateMachine*)
- getAgpsStateMachine(*locEng, mType);
- if (sm) {
- ATLSubscriber s(mID,
- sm,
- locEng->adapter,
- LOC_AGPS_TYPE_INVALID == mType);
- sm->subscribeRsrc((Subscriber*)&s);
- } else {
- locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType);
- }
-}
-inline void LocEngRequestATL::locallog() const {
- LOC_LOGV("LocEngRequestATL");
-}
-inline void LocEngRequestATL::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_RELEASE_ATL:
-LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) :
- LocMsg(), mLocEng(locEng), mID(id) {
- locallog();
-}
-void LocEngReleaseATL::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
-
- if (locEng->agnss_nif) {
- ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false);
- if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) {
- LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif",
- __func__, __LINE__);
- return;
- }
- }
-
- if (locEng->internet_nif) {
- ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false);
- if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) {
- LOC_LOGD("%s:%d]: Unsubscribed from internet_nif",
- __func__, __LINE__);
- return;
- }
- }
-
- if (locEng->ds_nif) {
- DSSubscriber s3(locEng->ds_nif, mID);
- if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) {
- LOC_LOGD("%s:%d]: Unsubscribed from ds_nif",
- __func__, __LINE__);
- return;
- }
- }
-
- LOC_LOGW("%s:%d]: Could not release ATL. "
- "No subscribers found\n",
- __func__, __LINE__);
- locEng->adapter->atlCloseStatus(mID, 0);
-}
-inline void LocEngReleaseATL::locallog() const {
- LOC_LOGV("LocEngReleaseATL");
-}
-inline void LocEngReleaseATL::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REQUEST_WIFI:
-// case LOC_ENG_MSG_RELEASE_WIFI:
-LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type,
- loc_if_req_sender_id_e_type sender_id,
- char* s, char* p, bool isReq) :
- LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id),
- mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]),
- mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]),
- mIsReq(isReq) {
- if (NULL != s)
- strlcpy(mSSID, s, SSID_BUF_SIZE);
- if (NULL != p)
- strlcpy(mPassword, p, SSID_BUF_SIZE);
- locallog();
-}
-LocEngReqRelWifi::~LocEngReqRelWifi() {
- if (NULL != mSSID) {
- delete[] mSSID;
- }
- if (NULL != mPassword) {
- delete[] mPassword;
- }
-}
-void LocEngReqRelWifi::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType);
-}
-inline void LocEngReqRelWifi::locallog() const {
- LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s",
- mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi",
- mSenderId,
- NULL != mSSID ? mSSID : "",
- NULL != mPassword ? mPassword : "");
-}
-inline void LocEngReqRelWifi::log() const {
- locallog();
-}
-void LocEngReqRelWifi::send() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- locEng->adapter->sendMsg(this);
-}
-
-// case LOC_ENG_MSG_REQUEST_XTRA_DATA:
-LocEngRequestXtra::LocEngRequestXtra(void* locEng) :
- mLocEng(locEng) {
- locallog();
-}
-void LocEngRequestXtra::proc() const
-{
- loc_eng_xtra_data_s_type* locEngXtra =
- &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data);
-
- if (locEngXtra->download_request_cb != NULL) {
- CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng);
- locEngXtra->download_request_cb();
- } else {
- LOC_LOGE("Callback function for request xtra is NULL");
- }
-}
-inline void LocEngRequestXtra::locallog() const {
- LOC_LOGV("LocEngReqXtra");
-}
-inline void LocEngRequestXtra::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_REQUEST_TIME:
-LocEngRequestTime::LocEngRequestTime(void* locEng) :
- LocMsg(), mLocEng(locEng)
-{
- locallog();
-}
-void LocEngRequestTime::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- if (gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_ON_DEMAND_TIME) {
- if (locEng->request_utc_time_cb != NULL) {
- locEng->request_utc_time_cb();
- } else {
- LOC_LOGE("Callback function for request time is NULL");
- }
- }
-}
-inline void LocEngRequestTime::locallog() const {
- LOC_LOGV("LocEngReqTime");
-}
-inline void LocEngRequestTime::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_DELETE_AIDING_DATA:
-struct LocEngDelAidData : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- const LocGpsAidingData mType;
- inline LocEngDelAidData(loc_eng_data_s_type* locEng,
- LocGpsAidingData f) :
- LocMsg(), mLocEng(locEng), mType(f)
- {
- locallog();
- }
- inline virtual void proc() const {
- mLocEng->aiding_data_for_deletion = mType;
- update_aiding_data_for_deletion(*mLocEng);
- }
- inline void locallog() const {
- LOC_LOGV("aiding data msak %d", mType);
- }
- virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_ENABLE_DATA:
-struct LocEngEnableData : public LocMsg {
- LocEngAdapter* mAdapter;
- const int mEnable;
- char* mAPN;
- const int mLen;
- inline LocEngEnableData(LocEngAdapter* adapter,
- const char* name, int len, int enable) :
- LocMsg(), mAdapter(adapter),
- mEnable(enable), mAPN(NULL), mLen(len)
- {
- if (NULL != name) {
- mAPN = new char[len+1];
- memcpy((void*)mAPN, (void*)name, len);
- mAPN[len] = 0;
- }
- locallog();
- }
- inline ~LocEngEnableData() {
- if (NULL != mAPN) {
- delete[] mAPN;
- }
- }
- inline virtual void proc() const {
- mAdapter->enableData(mEnable);
- if (NULL != mAPN) {
- mAdapter->setAPN(mAPN, mLen);
- }
- }
- inline void locallog() const {
- LOC_LOGV("apn: %s\n enable: %d",
- (NULL == mAPN) ? "NULL" : mAPN, mEnable);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_INJECT_XTRA_DATA:
-// loc_eng_xtra.cpp
-
-// case LOC_ENG_MSG_SET_CAPABILITIES:
-struct LocEngSetCapabilities : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) :
- LocMsg(), mLocEng(locEng)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (NULL != mLocEng->set_capabilities_cb) {
- LOC_LOGV("calling set_capabilities_cb 0x%x",
- gps_conf.CAPABILITIES);
- mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES);
- } else {
- LOC_LOGV("set_capabilities_cb is NULL.\n");
- }
- }
- inline void locallog() const
- {
- LOC_LOGV("LocEngSetCapabilities");
- }
- inline virtual void log() const
- {
- locallog();
- }
-};
-
-struct LocEngSetSystemInfo : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) :
- LocMsg(), mLocEng(locEng)
- {
- locallog();
- }
- inline virtual void proc() const {
- if (NULL != mLocEng->set_system_info_cb) {
- LOC_LOGV("calling set_system_info_cb 0x%x",
- mLocEng->adapter->mGnssInfo.year_of_hw);
- mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo));
- }
- else {
- LOC_LOGV("set_system_info_cb is NULL.\n");
- }
- }
- inline void locallog() const
- {
- LOC_LOGV("LocEngSetSystemInfo");
- }
- inline virtual void log() const
- {
- locallog();
- }
-};
-// case LOC_ENG_MSG_LOC_INIT:
-struct LocEngInit : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- inline LocEngInit(loc_eng_data_s_type* locEng) :
- LocMsg(), mLocEng(locEng)
- {
- locallog();
- }
- inline virtual void proc() const {
- loc_eng_reinit(*mLocEng);
- // set the capabilities
- mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng));
- mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng));
- }
- inline void locallog() const
- {
- LOC_LOGV("LocEngInit");
- }
- inline virtual void log() const
- {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_REQUEST_XTRA_SERVER:
-// loc_eng_xtra.cpp
-
-// case LOC_ENG_MSG_ATL_OPEN_SUCCESS:
-struct LocEngAtlOpenSuccess : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- const AGpsExtType mAgpsType;
- const int mLen;
- char* mAPN;
- const AGpsBearerType mBearerType;
- inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng,
- const AGpsExtType agpsType,
- const char* name,
- int len,
- AGpsBearerType btype) :
- LocMsg(),
- mLocEng(locEng), mAgpsType(agpsType), mLen(len),
- mAPN(new char[len+1]), mBearerType(btype)
- {
- memcpy((void*)mAPN, (void*)name, len);
- mAPN[len] = 0;
- locallog();
- }
- inline ~LocEngAtlOpenSuccess()
- {
- delete[] mAPN;
- }
- inline virtual void proc() const {
- AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
- sm->setBearer(mBearerType);
- sm->setAPN(mAPN, mLen);
- sm->onRsrcEvent(RSRC_GRANTED);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n"
- " bearer type: %s",
- loc_get_agps_type_name(mAgpsType),
- mAPN,
- loc_get_agps_bear_name(mBearerType));
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_ATL_CLOSED:
-struct LocEngAtlClosed : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- const AGpsExtType mAgpsType;
- inline LocEngAtlClosed(loc_eng_data_s_type* locEng,
- const AGpsExtType agpsType) :
- LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
- locallog();
- }
- inline virtual void proc() const {
- AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
- sm->onRsrcEvent(RSRC_RELEASED);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngAtlClosed");
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_ATL_OPEN_FAILED:
-struct LocEngAtlOpenFailed : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- const AGpsExtType mAgpsType;
- inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng,
- const AGpsExtType agpsType) :
- LocMsg(), mLocEng(locEng), mAgpsType(agpsType) {
- locallog();
- }
- inline virtual void proc() const {
- AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType);
- sm->onRsrcEvent(RSRC_DENIED);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngAtlOpenFailed");
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_ENGINE_DOWN:
-LocEngDown::LocEngDown(void* locEng) :
- LocMsg(), mLocEng(locEng) {
- locallog();
-}
-inline void LocEngDown::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- loc_eng_handle_engine_down(*locEng);
-}
-inline void LocEngDown::locallog() const {
- LOC_LOGV("LocEngDown");
-}
-inline void LocEngDown::log() const {
- locallog();
-}
-
-// case LOC_ENG_MSG_ENGINE_UP:
-LocEngUp::LocEngUp(void* locEng) :
- LocMsg(), mLocEng(locEng) {
- locallog();
-}
-inline void LocEngUp::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng;
- loc_eng_handle_engine_up(*locEng);
-}
-inline void LocEngUp::locallog() const {
- LOC_LOGV("LocEngUp");
-}
-inline void LocEngUp::log() const {
- locallog();
-}
-
-struct LocEngAgnssNifInit : public LocMsg {
- loc_eng_data_s_type* mLocEng;
- inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) :
- LocMsg(), mLocEng(locEng) {
- locallog();
- }
- virtual void proc() const {
- createAgnssNifs(*mLocEng);
- }
- void locallog() const {
- LOC_LOGV("LocEngAgnssNifInit\n");
- }
- virtual void log() const {
- locallog();
- }
-};
-
-struct LocEngInstallAGpsCert : public LocMsg {
- LocEngAdapter* mpAdapter;
- const size_t mNumberOfCerts;
- const uint32_t mSlotBitMask;
- LocDerEncodedCertificate* mpData;
- inline LocEngInstallAGpsCert(LocEngAdapter* adapter,
- const LocDerEncodedCertificate* pData,
- size_t numberOfCerts,
- uint32_t slotBitMask) :
- LocMsg(), mpAdapter(adapter),
- mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask),
- mpData(new LocDerEncodedCertificate[mNumberOfCerts])
- {
- for (int i=0; i < mNumberOfCerts; i++) {
- mpData[i].data = new u_char[pData[i].length];
- if (mpData[i].data) {
- memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length);
- mpData[i].length = pData[i].length;
- } else {
- LOC_LOGE("malloc failed for cert#%d", i);
- break;
- }
- }
- locallog();
- }
- inline ~LocEngInstallAGpsCert()
- {
- for (int i=0; i < mNumberOfCerts; i++) {
- if (mpData[i].data) {
- delete[] mpData[i].data;
- }
- }
- delete[] mpData;
- }
- inline virtual void proc() const {
- mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask);
- }
- inline void locallog() const {
- LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u",
- mNumberOfCerts, mSlotBitMask);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-struct LocEngGnssConstellationConfig : public LocMsg {
- LocEngAdapter* mAdapter;
- inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter) {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->mGnssInfo.size = sizeof(LocGnssSystemInfo);
- if (mAdapter->gnssConstellationConfig()) {
- LOC_LOGV("Modem supports GNSS measurements\n");
- gps_conf.CAPABILITIES |= LOC_GPS_CAPABILITY_MEASUREMENTS;
- mAdapter->mGnssInfo.year_of_hw = 2016;
- } else {
- mAdapter->mGnssInfo.year_of_hw = 2015;
- LOC_LOGV("Modem does not support GNSS measurements\n");
- }
- }
- void locallog() const {
- LOC_LOGV("LocEngGnssConstellationConfig\n");
- }
- virtual void log() const {
- locallog();
- }
-};
-
-// case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT:
-LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng,
- LocGnssData &gnssData) :
- LocMsg(), mLocEng(locEng), mGnssData(gnssData)
-{
- locallog();
-}
-void LocEngReportGnssMeasurement::proc() const {
- loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng;
- if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION)
- {
- if (locEng->gnss_measurement_cb != NULL) {
- LOC_LOGV("Calling gnss_measurement_cb");
- locEng->gnss_measurement_cb((LocGnssData*)&(mGnssData));
- }
- }
-}
-void LocEngReportGnssMeasurement::locallog() const {
- IF_LOC_LOGV {
- LOC_LOGV("%s:%d]: Received in GPS HAL."
- "GNSS Measurements count: %d \n",
- __func__, __LINE__, mGnssData.measurement_count);
- for (int i =0; i< mGnssData.measurement_count && i < LOC_GNSS_MAX_SVS; i++) {
- LOC_LOGV(" GNSS measurement data in GPS HAL: \n"
- " GPS_HAL => Measurement ID | svid | time_offset_ns | state |"
- " c_n0_dbhz | pseudorange_rate_mps |"
- " pseudorange_rate_uncertainty_mps |"
- " accumulated_delta_range_state | flags \n"
- " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n",
- i,
- mGnssData.measurements[i].svid,
- mGnssData.measurements[i].time_offset_ns,
- mGnssData.measurements[i].state,
- mGnssData.measurements[i].c_n0_dbhz,
- mGnssData.measurements[i].pseudorange_rate_mps,
- mGnssData.measurements[i].pseudorange_rate_uncertainty_mps,
- mGnssData.measurements[i].accumulated_delta_range_state,
- mGnssData.measurements[i].flags);
- }
- LOC_LOGV(" GPS_HAL => Clocks Info: \n"
- " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | "
- " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags"
- " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n",
- mGnssData.clock.time_ns,
- mGnssData.clock.full_bias_ns,
- mGnssData.clock.bias_ns,
- mGnssData.clock.bias_uncertainty_ns,
- mGnssData.clock.drift_nsps,
- mGnssData.clock.drift_uncertainty_nsps,
- mGnssData.clock.hw_clock_discontinuity_count,
- mGnssData.clock.flags);
- }
-}
-inline void LocEngReportGnssMeasurement::log() const {
- locallog();
-}
-
-/*********************************************************************
- * Initialization checking macros
- *********************************************************************/
-#define STATE_CHECK(ctx, x, ret) \
- if (!(ctx)) \
- { \
- /* Not intialized, abort */\
- LOC_LOGE("%s: log_eng state error: %s", __func__, x); \
- EXIT_LOG(%s, x); \
- ret; \
- }
-#define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret)
-
-/*===========================================================================
-FUNCTION loc_eng_init
-
-DESCRIPTION
- Initialize the location engine, this include setting up global datas
- and registers location engien with loc api service.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks,
- LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context)
-
-{
- int ret_val = 0;
-
- ENTRY_LOG_CALLFLOW();
- if (NULL == callbacks || 0 == event) {
- LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event);
- ret_val = -1;
- EXIT_LOG(%d, ret_val);
- return ret_val;
- }
-
- STATE_CHECK((NULL == loc_eng_data.adapter),
- "instance already initialized", return 0);
-
- memset(&loc_eng_data, 0, sizeof (loc_eng_data));
-
- // Save callbacks
- loc_eng_data.location_cb = callbacks->location_cb;
- loc_eng_data.sv_status_cb = callbacks->sv_status_cb;
- loc_eng_data.status_cb = callbacks->status_cb;
- loc_eng_data.nmea_cb = callbacks->nmea_cb;
- loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb;
- loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb;
- loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb;
- loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb;
- loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb;
- loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb;
- loc_eng_data.location_ext_parser = callbacks->location_ext_parser ?
- callbacks->location_ext_parser : noProc;
- loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ?
- callbacks->sv_ext_parser : noProc;
- loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS;
- // initial states taken care of by the memset above
- // loc_eng_data.engine_status -- LOC_GPS_STATUS_NONE;
- // loc_eng_data.fix_session_status -- LOC_GPS_STATUS_NONE;
- // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE;
-
- if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP))
- {
- event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report
- loc_eng_data.generateNmea = true;
- }
- else if (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_MP)
- {
- loc_eng_data.generateNmea = false;
- }
-
- loc_eng_data.adapter =
- new LocEngAdapter(event, &loc_eng_data, context,
- (LocThread::tCreate)callbacks->create_thread_cb);
-
- loc_eng_data.adapter->mGnssInfo.size = sizeof(LocGnssSystemInfo);
- loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015;
- LOC_LOGD("loc_eng_init created client, id = %p\n",
- loc_eng_data.adapter);
- loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data));
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
- LocEngAdapter* adapter = loc_eng_data.adapter;
-
- adapter->sendMsg(new LocEngGnssConstellationConfig(adapter));
- adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
- adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
- adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE,
- sap_conf.SENSOR_PROVIDER));
- adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
- adapter->sendMsg(new LocEngLPPeProtocol(adapter, gps_conf.LPPE_CP_TECHNOLOGY,
- gps_conf.LPPE_UP_TECHNOLOGY));
-
- if (!loc_eng_data.generateNmea)
- {
- NmeaSentenceTypesMask typesMask = LOC_NMEA_ALL_SUPPORTED_MASK;
- LOC_LOGD("loc_eng_init setting nmea types, mask = %u\n",typesMask);
- adapter->sendMsg(new LocEngSetNmeaTypes(adapter,typesMask));
- }
-
- /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */
- if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
- sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
- sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
- sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
- sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
- adapter->sendMsg(new LocEngSensorProperties(adapter,
- sap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
- sap_conf.GYRO_BIAS_RANDOM_WALK,
- sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
- sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
- sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
- sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
- sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
- sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
- sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
- sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY));
- }
-
- adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter,
- sap_conf.SENSOR_CONTROL_MODE,
- sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
- sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
- sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
- sap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
- sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
- sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
- sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
- sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
- sap_conf.SENSOR_ALGORITHM_CONFIG_MASK));
-
- adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0)));
-
- loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK);
-
- LOC_LOGD("loc_eng_reinit reinit() successful");
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_cleanup
-
-DESCRIPTION
- Cleans location engine. The location client handle will be released.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return);
-
- // XTRA has no state, so we are fine with it.
-
- // we need to check and clear NI
-#if 0
- // we need to check and clear ATL
- if (NULL != loc_eng_data.agnss_nif) {
- delete loc_eng_data.agnss_nif;
- loc_eng_data.agnss_nif = NULL;
- }
- if (NULL != loc_eng_data.internet_nif) {
- delete loc_eng_data.internet_nif;
- loc_eng_data.internet_nif = NULL;
- }
-#endif
- if (loc_eng_data.adapter->isInSession())
- {
- LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now.");
- loc_eng_stop(loc_eng_data);
- }
-
-#if 0 // can't afford to actually clean up, for many reason.
-
- LOC_LOGD("loc_eng_init: client opened. close it now.");
- delete loc_eng_data.adapter;
- loc_eng_data.adapter = NULL;
-
- loc_eng_dmn_conn_loc_api_server_unblock();
- loc_eng_dmn_conn_loc_api_server_join();
-
-#endif
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_start
-
-DESCRIPTION
- Starts the tracking session
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_start(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return -1);
-
- if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix())
- {
- loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter));
- }
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
-
- if (!loc_eng_data.adapter->isInSession()) {
- ret_val = loc_eng_data.adapter->startFix();
-
- if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS ||
- ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN ||
- ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE ||
- ret_val == LOC_API_ADAPTER_ERR_INTERNAL)
- {
- loc_eng_data.adapter->setInSession(TRUE);
- }
- }
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_stop_wrapper
-
-DESCRIPTION
- Stops the tracking session
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_stop(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return -1);
-
- if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix())
- {
- loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter));
- }
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
-
- if (loc_eng_data.adapter->isInSession()) {
- ret_val = loc_eng_data.adapter->stopFix();
- loc_eng_data.adapter->setInSession(FALSE);
- }
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_mute_one_session
-
-DESCRIPTION
- Mutes one session
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: Success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT;
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_set_position_mode
-
-DESCRIPTION
- Sets the mode and fix frequency for the tracking session.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
- LocPosMode ¶ms)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return -1);
-
- // When MSA tracking session is triggered, fallback to MSB based
- // tracking if MSB is supported or standalone tracking
- if (params.mode == LOC_POSITION_MODE_MS_ASSISTED) {
- if (params.recurrence == LOC_GPS_POSITION_RECURRENCE_PERIODIC) {
- params.mode = LOC_POSITION_MODE_MS_BASED;
- } else if (!(ContextBase::getCarrierCapabilities() & LOC_GPS_CAPABILITY_MSA)) {
- // MSA is not supported, default to standalone
- params.mode = LOC_POSITION_MODE_STANDALONE;
- }
- }
-
- if (params.mode == LOC_POSITION_MODE_MS_BASED &&
- !(ContextBase::getCarrierCapabilities() & LOC_GPS_CAPABILITY_MSB)) {
- // If MSB is not supported, default to standalone
- params.mode = LOC_POSITION_MODE_STANDALONE;
- }
-
- if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params))
- {
- LocEngAdapter* adapter = loc_eng_data.adapter;
- adapter->sendMsg(new LocEngPositionMode(adapter, params));
- }
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_inject_time
-
-DESCRIPTION
- This is used by Java native function to do time injection.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, LocGpsUtcTime time,
- int64_t timeReference, int uncertainty)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return -1);
- LocEngAdapter* adapter = loc_eng_data.adapter;
-
- adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference,
- uncertainty));
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_inject_location
-
-DESCRIPTION
- This is used by Java native function to do location injection.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0 : Successful
- error code : Failure
-
-SIDE EFFECTS
- N/A
-===========================================================================*/
-int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude,
- double longitude, float accuracy)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return -1);
- LocEngAdapter* adapter = loc_eng_data.adapter;
- if(adapter->mSupportsPositionInjection)
- {
- adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude,
- accuracy));
- }
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_delete_aiding_data
-
-DESCRIPTION
- This is used by Java native function to delete the aiding data. The function
- updates the global variable for the aiding data to be deleted. If the GPS
- engine is off, the aiding data will be deleted. Otherwise, the actual action
- will happen when gps engine is turned off.
-
-DEPENDENCIES
- Assumes the aiding data type specified in LocGpsAidingData matches with
- LOC API specification.
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, LocGpsAidingData f)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return);
-
- //report delete aiding data to ULP to send to DRPlugin
- loc_eng_data.adapter->getUlpProxy()->reportDeleteAidingData(f);
-
- loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f));
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-
-FUNCTION loc_inform_gps_state
-
-DESCRIPTION
- Informs the GPS Provider about the GPS status
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, LocGpsStatusValue status)
-{
- ENTRY_LOG();
-
- if (loc_eng_data.status_cb)
- {
- LocGpsStatus gs = { sizeof(gs),status };
- CALLBACK_LOG_CALLFLOW("status_cb", %s,
- loc_get_gps_status_name(gs.status));
- loc_eng_data.status_cb(&gs);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- int ret_val = LOC_API_ADAPTER_ERR_SUCCESS;
- UlpLocation location;
- LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT;
- GpsLocationExtended locationExtended;
- memset(&locationExtended, 0, sizeof (GpsLocationExtended));
- locationExtended.size = sizeof(locationExtended);
-
- ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask);
- //Mark the location source as from ZPP
- location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
- location.position_source = ULP_LOCATION_IS_FROM_ZPP;
-
- loc_eng_data.adapter->getUlpProxy()->reportPosition(location,
- locationExtended,
- NULL,
- LOC_SESS_SUCCESS,
- tech_mask);
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*
- Callback function passed to Data Services State Machine
- This becomes part of the state machine's servicer and
- is used to send requests to the data services client
-*/
-static int dataCallCb(void *cb_data)
-{
- LOC_LOGD("Enter dataCallCb\n");
- int ret=0;
- if(cb_data != NULL) {
- dsCbData *cbData = (dsCbData *)cb_data;
- LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter;
- if(cbData->action == LOC_GPS_REQUEST_AGPS_DATA_CONN) {
- LOC_LOGD("dataCallCb LOC_GPS_REQUEST_AGPS_DATA_CONN\n");
- ret = locAdapter->openAndStartDataCall();
- }
- else if(cbData->action == LOC_GPS_RELEASE_AGPS_DATA_CONN) {
- LOC_LOGD("dataCallCb LOC_GPS_RELEASE_AGPS_DATA_CONN\n");
- locAdapter->stopDataCall();
- }
- }
- else {
- LOC_LOGE("NULL argument received. Failing.\n");
- ret = -1;
- goto err;
- }
-
-err:
- LOC_LOGD("Exit dataCallCb ret = %d\n", ret);
- return ret;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_agps_reinit
-
-DESCRIPTION
- 2nd half of loc_eng_agps_init(), singled out for modem restart to use.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
-
- // Set server addresses which came before init
- if (loc_eng_data.supl_host_set)
- {
- loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER,
- loc_eng_data.supl_host_buf,
- loc_eng_data.supl_port_buf);
- }
-
- if (loc_eng_data.c2k_host_set)
- {
- loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER,
- loc_eng_data.c2k_host_buf,
- loc_eng_data.c2k_port_buf);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dsclient_release
-
-DESCRIPTION
- Stop/Close/Release DS client when modem SSR happens.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_eng_dsclient_release(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- int result = 1;
- LocEngAdapter* adapter = loc_eng_data.adapter;
- if (NULL != adapter && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL)
- {
- // stop and close the ds client
- adapter->stopDataCall();
- adapter->closeDataCall();
- adapter->releaseDataServiceClient();
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_agps_init
-
-DESCRIPTION
- Initialize the AGps interface.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter, return);
- STATE_CHECK((NULL == loc_eng_data.agps_status_cb),
- "agps instance already initialized",
- return);
- if (callbacks == NULL) {
- LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks);
- EXIT_LOG(%s, VOID_RET);
- return;
- }
- LocEngAdapter* adapter = loc_eng_data.adapter;
- loc_eng_data.agps_status_cb = callbacks->status_cb;
-
- if (NULL != adapter) {
- if (adapter->mSupportsAgpsRequests) {
- adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data));
- }
- loc_eng_agps_reinit(loc_eng_data);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-static void deleteAidingData(loc_eng_data_s_type &logEng) {
- if (logEng.engine_status != LOC_GPS_STATUS_ENGINE_ON &&
- logEng.aiding_data_for_deletion != 0) {
- logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion);
- logEng.aiding_data_for_deletion = 0;
- }
-}
-
-// must be called under msg handler context
-static void createAgnssNifs(loc_eng_data_s_type& locEng) {
- bool agpsCapable = ((gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) ||
- (gps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB));
- LocEngAdapter* adapter = locEng.adapter;
- if (NULL != adapter && adapter->mSupportsAgpsRequests) {
- if (NULL == locEng.internet_nif) {
- locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps,
- (void *)locEng.agps_status_cb,
- LOC_AGPS_TYPE_WWAN_ANY,
- false);
- }
- if (agpsCapable) {
- if (NULL == locEng.agnss_nif) {
- locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps,
- (void *)locEng.agps_status_cb,
- LOC_AGPS_TYPE_SUPL,
- false);
- }
- if (NULL == locEng.ds_nif &&
- gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL &&
- 0 == adapter->initDataServiceClient(false)) {
- locEng.ds_nif = new DSStateMachine(servicerTypeExt,
- (void *)dataCallCb,
- locEng.adapter);
- }
- }
- }
-}
-
-// must be called under msg handler context
-static AgpsStateMachine*
-getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) {
- AgpsStateMachine* stateMachine;
- switch (agpsType) {
- case LOC_AGPS_TYPE_INVALID:
- case LOC_AGPS_TYPE_SUPL: {
- stateMachine = locEng.agnss_nif;
- break;
- }
- case LOC_AGPS_TYPE_SUPL_ES: {
- if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
- if (NULL == locEng.ds_nif) {
- createAgnssNifs(locEng);
- }
- stateMachine = locEng.ds_nif;
- } else {
- stateMachine = locEng.agnss_nif;
- }
- break;
- }
- default:
- stateMachine = locEng.internet_nif;
- }
- return stateMachine;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_agps_open
-
-DESCRIPTION
- This function is called when on-demand data connection opening is successful.
-It should inform engine about the data open result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
- const char* apn, AGpsBearerType bearerType)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
- return -1);
-
- if (apn == NULL)
- {
- LOC_LOGE("APN Name NULL\n");
- return 0;
- }
-
- LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn);
-
- int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
- loc_eng_data.adapter->sendMsg(
- new LocEngAtlOpenSuccess(&loc_eng_data, agpsType,
- apn, apn_len, bearerType));
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_agps_closed
-
-DESCRIPTION
- This function is called when on-demand data connection closing is done.
-It should inform engine about the data close result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
- return -1);
-
- loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data,
- agpsType));
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_agps_open_failed
-
-DESCRIPTION
- This function is called when on-demand data connection opening has failed.
-It should inform engine about the data open result.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType)
-{
- ENTRY_LOG_CALLFLOW();
- INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb,
- return -1);
-
- loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data,
- agpsType));
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-/*===========================================================================
-
-FUNCTION resolve_in_addr
-
-DESCRIPTION
- Translates a hostname to in_addr struct
-
-DEPENDENCIES
- n/a
-
-RETURN VALUE
- TRUE if successful
-
-SIDE EFFECTS
- n/a
-
-===========================================================================*/
-static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr)
-{
- ENTRY_LOG();
- boolean ret_val = TRUE;
-
- struct hostent *hp;
- hp = gethostbyname(host_addr);
- if (hp != NULL) /* DNS OK */
- {
- memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length);
- }
- else
- {
- /* Try IP representation */
- if (inet_aton(host_addr, in_addr_ptr) == 0)
- {
- /* IP not valid */
- LOC_LOGE("DNS query on '%s' failed\n", host_addr);
- ret_val = FALSE;
- }
- }
-
- EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_set_server
-
-DESCRIPTION
- This is used to set the default AGPS server. Server address is obtained
- from gps.conf.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data,
- LocServerType type, const char* hostname, int port)
-{
- ENTRY_LOG();
- int ret = 0;
- LocEngAdapter* adapter = loc_eng_data.adapter;
-
- if (LOC_AGPS_SUPL_SERVER == type) {
- char url[MAX_URL_LEN];
- unsigned int len = 0;
- const char nohost[] = "NONE";
- if (hostname == NULL ||
- strncasecmp(nohost, hostname, sizeof(nohost)) == 0) {
- url[0] = NULL;
- } else {
- len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port);
- }
-
- if (sizeof(url) > len) {
- adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len));
- }
- } else if (LOC_AGPS_CDMA_PDE_SERVER == type ||
- LOC_AGPS_CUSTOM_PDE_SERVER == type ||
- LOC_AGPS_MPC_SERVER == type) {
- struct in_addr addr;
- if (!resolve_in_addr(hostname, &addr))
- {
- LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname);
- ret = -2;
- } else {
- unsigned int ip = htonl(addr.s_addr);
- adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type));
- }
- } else {
- LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type);
- }
-
- EXIT_LOG(%d, ret);
- return ret;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_set_server_proxy
-
-DESCRIPTION
- If loc_eng_set_server is called before loc_eng_init, it doesn't work. This
- proxy buffers server settings and calls loc_eng_set_server when the client is
- open.
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
- LocServerType type,
- const char* hostname, int port)
-{
- ENTRY_LOG_CALLFLOW();
- int ret_val = 0;
-
- LOC_LOGV("save the address, type: %d, hostname: %s, port: %d",
- (int) type, hostname, port);
- switch (type)
- {
- case LOC_AGPS_SUPL_SERVER:
- strlcpy(loc_eng_data.supl_host_buf, hostname,
- sizeof(loc_eng_data.supl_host_buf));
- loc_eng_data.supl_port_buf = port;
- loc_eng_data.supl_host_set = 1;
- break;
- case LOC_AGPS_CDMA_PDE_SERVER:
- strlcpy(loc_eng_data.c2k_host_buf, hostname,
- sizeof(loc_eng_data.c2k_host_buf));
- loc_eng_data.c2k_port_buf = port;
- loc_eng_data.c2k_host_set = 1;
- break;
- default:
- LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type);
- }
-
- if (NULL != loc_eng_data.adapter)
- {
- ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port);
- }
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_agps_ril_update_network_availability
-
-DESCRIPTION
- Sets data call allow vs disallow flag to modem
- This is the only member of sLocEngAGpsRilInterface implemented.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
- int available, const char* apn)
-{
- ENTRY_LOG_CALLFLOW();
-
- //This is to store the status of data availability over the network.
- //If GPS is not enabled, the INIT_CHECK will fail and the modem will
- //not be updated with the network's availability. Since the data status
- //can change before GPS is enabled the, storing the status will enable
- //us to inform the modem after GPS is enabled
- agpsStatus = available;
-
- INIT_CHECK(loc_eng_data.adapter, return);
- if (apn != NULL)
- {
- LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn);
- int apn_len = smaller_of(strlen (apn), MAX_APN_LEN);
- LocEngAdapter* adapter = loc_eng_data.adapter;
- adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available));
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
- const LocDerEncodedCertificate* certificates,
- size_t numberOfCerts)
-{
- ENTRY_LOG_CALLFLOW();
- int ret_val = LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS;
-
- uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK;
- uint32_t slotCount = 0;
- for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) {
- slotBitMaskCounter &= slotBitMaskCounter - 1;
- }
- LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u",
- slotBitMask, slotCount, numberOfCerts);
-
- LocEngAdapter* adapter = loc_eng_data.adapter;
-
- if (numberOfCerts == 0) {
- LOC_LOGE("No certs to install, since numberOfCerts is zero");
- ret_val = LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS;
- } else if (!adapter) {
- LOC_LOGE("adapter is null!");
- ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC;
- } else if (slotCount < numberOfCerts) {
- LOC_LOGE("Not enough cert slots (%u) to install %u certs!",
- slotCount, numberOfCerts);
- ret_val = LOC_AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES;
- } else {
- for (int i=0; i < numberOfCerts; ++i)
- {
- if (certificates[i].length > LOC_AGPS_CERTIFICATE_MAX_LENGTH) {
- LOC_LOGE("cert#(%u) length of %u is too big! greater than %u",
- certificates[i].length, LOC_AGPS_CERTIFICATE_MAX_LENGTH);
- ret_val = LOC_AGPS_CERTIFICATE_ERROR_GENERIC;
- break;
- }
- }
-
- if (ret_val == LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS) {
- adapter->sendMsg(new LocEngInstallAGpsCert(adapter,
- certificates,
- numberOfCerts,
- slotBitMask));
- }
- }
-
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
- const char* config_data, int32_t length)
-{
- ENTRY_LOG_CALLFLOW();
-
- if (config_data && length > 0) {
- loc_gps_cfg_s_type gps_conf_tmp = gps_conf;
- UTIL_UPDATE_CONF(config_data, length, gps_conf_table);
- LocEngAdapter* adapter = loc_eng_data.adapter;
-
- // it is possible that HAL is not init'ed at this time
- if (adapter) {
- if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) {
- adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER));
- }
- if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) {
- adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE));
- }
- if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) {
- adapter->sendMsg(new LocEngAGlonassProtocol(adapter,
- gps_conf.A_GLONASS_POS_PROTOCOL_SELECT));
- }
- if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) {
- adapter->sendMsg(new LocEngSuplMode(adapter));
- }
- // we always update lock mask, this is because if this is dsds device, we would not
- // know if modem has switched dds, if so, lock mask may also need to be updated.
- // if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK.
- adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK);
- }
-
- gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER;
- gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE;
- gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT;
- gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE;
- gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES;
- gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK;
- gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL =
- gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
- gps_conf = gps_conf_tmp;
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_report_status
-
-DESCRIPTION
- Reports GPS engine state to Java layer.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- N/A
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void loc_eng_report_status (loc_eng_data_s_type &loc_eng_data, LocGpsStatusValue status)
-{
- ENTRY_LOG();
- // Switch from WAIT to MUTE, for "engine on" or "session begin" event
- if (status == LOC_GPS_STATUS_SESSION_BEGIN || status == LOC_GPS_STATUS_ENGINE_ON)
- {
- if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT)
- {
- LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION");
- loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION;
- }
- }
-
- // Switch off MUTE session
- if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION &&
- (status == LOC_GPS_STATUS_SESSION_END || status == LOC_GPS_STATUS_ENGINE_OFF))
- {
- LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE");
- loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE;
- }
-
- // Session End is not reported during Android navigating state
- boolean navigating = loc_eng_data.adapter->isInSession();
- if (status != LOC_GPS_STATUS_NONE &&
- !(status == LOC_GPS_STATUS_SESSION_END && navigating) &&
- !(status == LOC_GPS_STATUS_SESSION_BEGIN && !navigating))
- {
- if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION)
- {
- // Inform GpsLocationProvider about mNavigating status
- loc_inform_gps_status(loc_eng_data, status);
- }
- else {
- LOC_LOGD("loc_eng_report_status: muting the status report.");
- }
- }
-
- // Only keeps ENGINE ON/OFF in engine_status
- if (status == LOC_GPS_STATUS_ENGINE_ON || status == LOC_GPS_STATUS_ENGINE_OFF)
- {
- loc_eng_data.engine_status = status;
- }
-
- // Only keeps SESSION BEGIN/END in fix_session_status
- if (status == LOC_GPS_STATUS_SESSION_BEGIN || status == LOC_GPS_STATUS_SESSION_END)
- {
- loc_eng_data.fix_session_status = status;
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_handle_engine_down
- loc_eng_handle_engine_up
-
-DESCRIPTION
- Calls this function when it is detected that modem restart is happening.
- Either we detected the modem is down or received modem up event.
- This must be called from the deferred thread to avoid race condition.
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- loc_eng_ni_reset_on_engine_restart(loc_eng_data);
- loc_eng_report_status(loc_eng_data, LOC_GPS_STATUS_ENGINE_OFF);
- EXIT_LOG(%s, VOID_RET);
-}
-
-void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- loc_eng_reinit(loc_eng_data);
-
- loc_eng_data.adapter->requestPowerVote();
-
- if (loc_eng_data.agps_status_cb != NULL) {
- if (loc_eng_data.agnss_nif)
- loc_eng_data.agnss_nif->dropAllSubscribers();
- if (loc_eng_data.internet_nif)
- loc_eng_data.internet_nif->dropAllSubscribers();
-
- // reinitialize DS client in SSR mode
- loc_eng_dsclient_release(loc_eng_data);
- if (loc_eng_data.adapter->mSupportsAgpsRequests &&
- gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
- loc_eng_data.adapter->initDataServiceClient(true);
- }
- loc_eng_agps_reinit(loc_eng_data);
- }
-
- // modem is back up. If we crashed in the middle of navigating, we restart.
- if (loc_eng_data.adapter->isInSession()) {
- // This sets the copy in adapter to modem
- loc_eng_data.adapter->setInSession(false);
- loc_eng_start_handler(loc_eng_data);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_read_config
-
-DESCRIPTION
- Initiates the reading of the gps config file stored in /etc dir
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_read_config(void)
-{
- ENTRY_LOG_CALLFLOW();
- if(configAlreadyRead == false)
- {
- // Initialize our defaults before reading of configuration file overwrites them.
- loc_default_parameters();
- // We only want to parse the conf file once. This is a good place to ensure that.
- // In fact one day the conf file should go into context.
- UTIL_READ_CONF(LOC_PATH_GPS_CONF, gps_conf_table);
- UTIL_READ_CONF(LOC_PATH_SAP_CONF, sap_conf_table);
- configAlreadyRead = true;
- } else {
- LOC_LOGV("GPS Config file has already been read\n");
- }
-
- EXIT_LOG(%d, 0);
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_gps_measurement_init
-
-DESCRIPTION
- Initialize gps measurement module.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
- LocGpsMeasurementCallbacks* callbacks)
-{
- ENTRY_LOG_CALLFLOW();
-
- STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb),
- "gnss measurement already initialized",
- return LOC_GPS_MEASUREMENT_ERROR_ALREADY_INIT);
- STATE_CHECK((callbacks != NULL),
- "callbacks can not be NULL",
- return LOC_GPS_MEASUREMENT_ERROR_GENERIC);
- STATE_CHECK(loc_eng_data.adapter,
- "LocGpsInterface must be initialized first",
- return LOC_GPS_MEASUREMENT_ERROR_GENERIC);
-
- // updated the mask
- LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
- loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_ENABLED);
- // set up the callback
- loc_eng_data.gnss_measurement_cb = callbacks->loc_gnss_measurement_callback;
- LOC_LOGD ("%s, event masks updated successfully", __func__);
-
- return LOC_GPS_MEASUREMENT_OPERATION_SUCCESS;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_gps_measurement_close
-
-DESCRIPTION
- Close gps measurement module.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- N/A
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG_CALLFLOW();
-
- INIT_CHECK(loc_eng_data.adapter, return);
-
- // updated the mask
- LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
- loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_DISABLED);
- // set up the callback
- loc_eng_data.gnss_measurement_cb = NULL;
- EXIT_LOG(%d, 0);
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng.h b/msm8998/loc_api/libloc_api_50001/loc_eng.h
deleted file mode 100644
index d78bef4..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/* Copyright (c) 2009-2014, 2016 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_H
-#define LOC_ENG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-// Uncomment to keep all LOG messages (LOGD, LOGI, LOGV, etc.)
-#define MAX_NUM_ATL_CONNECTIONS 2
-
-// Define boolean type to be used by libgps on loc api module
-typedef unsigned char boolean;
-
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-#ifndef FALSE
-#define FALSE 0
-#endif
-
-#include <loc.h>
-#include <loc_eng_xtra.h>
-#include <loc_eng_ni.h>
-#include <loc_eng_agps.h>
-#include <loc_cfg.h>
-#include <loc_log.h>
-#include <loc_eng_agps.h>
-#include <LocEngAdapter.h>
-
-// The data connection minimal open time
-#define DATA_OPEN_MIN_TIME 1 /* sec */
-
-// The system sees GPS engine turns off after inactive for this period of time
-#define GPS_AUTO_OFF_TIME 2 /* secs */
-#define SUCCESS TRUE
-#define FAILURE FALSE
-#define INVALID_ATL_CONNECTION_HANDLE -1
-
-#define gps_conf ContextBase::mGps_conf
-#define sap_conf ContextBase::mSap_conf
-
-enum loc_nmea_provider_e_type {
- NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA
- NMEA_PROVIDER_MP // Modem Processor Provider of NMEA
-};
-
-enum loc_mute_session_e_type {
- LOC_MUTE_SESS_NONE = 0,
- LOC_MUTE_SESS_WAIT,
- LOC_MUTE_SESS_IN_SESSION
-};
-
-// Module data
-typedef struct loc_eng_data_s
-{
- LocEngAdapter *adapter;
- loc_location_cb_ext location_cb;
- loc_gps_status_callback status_cb;
- loc_sv_status_cb_ext sv_status_cb;
- agps_status_extended agps_status_cb;
- loc_gps_nmea_callback nmea_cb;
- loc_ni_notify_callback ni_notify_cb;
- loc_gps_set_capabilities set_capabilities_cb;
- loc_gps_acquire_wakelock acquire_wakelock_cb;
- loc_gps_release_wakelock release_wakelock_cb;
- loc_gps_request_utc_time request_utc_time_cb;
- loc_gnss_set_system_info set_system_info_cb;
- loc_gnss_sv_status_callback gnss_sv_status_cb;
- loc_gnss_measurement_callback gnss_measurement_cb;
- boolean intermediateFix;
- LocAGpsStatusValue agps_status;
- loc_eng_xtra_data_s_type xtra_module_data;
- loc_eng_ni_data_s_type loc_eng_ni_data;
-
- // AGPS state machines
- AgpsStateMachine* agnss_nif;
- AgpsStateMachine* internet_nif;
- //State machine for Data Services
- AgpsStateMachine* ds_nif;
-
- // GPS engine status
- LocGpsStatusValue engine_status;
- LocGpsStatusValue fix_session_status;
-
- // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off
- LocGpsAidingData aiding_data_for_deletion;
-
- // For muting session broadcast
- loc_mute_session_e_type mute_session_state;
-
- // For nmea generation
- boolean generateNmea;
- uint32_t gps_used_mask;
- uint32_t glo_used_mask;
- uint32_t gal_used_mask;
- float hdop;
- float pdop;
- float vdop;
-
- // Address buffers, for addressing setting before init
- int supl_host_set;
- char supl_host_buf[101];
- int supl_port_buf;
- int c2k_host_set;
- char c2k_host_buf[101];
- int c2k_port_buf;
- int mpc_host_set;
- char mpc_host_buf[101];
- int mpc_port_buf;
-
- loc_ext_parser location_ext_parser;
- loc_ext_parser sv_ext_parser;
-} loc_eng_data_s_type;
-
-//loc_eng functions
-int loc_eng_init(loc_eng_data_s_type &loc_eng_data,
- LocCallbacks* callbacks,
- LOC_API_ADAPTER_EVENT_MASK_T event,
- ContextBase* context);
-int loc_eng_start(loc_eng_data_s_type &loc_eng_data);
-int loc_eng_stop(loc_eng_data_s_type &loc_eng_data);
-void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data);
-int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data,
- LocGpsUtcTime time, int64_t timeReference,
- int uncertainty);
-int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data,
- double latitude, double longitude,
- float accuracy);
-void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data,
- LocGpsAidingData f);
-int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data,
- LocPosMode ¶ms);
-const void* loc_eng_get_extension(loc_eng_data_s_type &loc_eng_data,
- const char* name);
-int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data,
- LocServerType type, const char *hostname, int port);
-void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data);
-int loc_eng_read_config(void);
-
-//loc_eng_agps functions
-void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data,
- AGpsExtCallbacks* callbacks);
-int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType,
- const char* apn, AGpsBearerType bearerType);
-int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType);
-int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType);
-void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data,
- int avaiable, const char* apn);
-int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data,
- const LocDerEncodedCertificate* certificates,
- size_t length);
-
-//loc_eng_xtra functions
-int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
- GpsXtraExtCallbacks* callbacks);
-int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
- char* data, int length);
-int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data);
-void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, int check);
-
-//loc_eng_ni functions
-extern void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data,
- GpsNiExtCallbacks *callbacks);
-extern void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
- int notif_id, LocGpsUserResponseType user_response);
-extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
- const LocGpsNiNotification *notif,
- const void* passThrough);
-extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data);
-
-void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data,
- const char* config_data, int32_t length);
-int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data,
- LocGpsMeasurementCallbacks* callbacks);
-void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif // LOC_ENG_H
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_agps.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_agps.cpp
deleted file mode 100644
index 93260e3..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_agps.cpp
+++ /dev/null
@@ -1,969 +0,0 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng"
-
-#include <loc_eng_agps.h>
-#include <loc_eng_log.h>
-#include <platform_lib_includes.h>
-#include <loc_eng_dmn_conn_handler.h>
-#include <loc_eng_dmn_conn.h>
-#include <sys/time.h>
-
-//======================================================================
-// C callbacks
-//======================================================================
-
-// This is given to linked_list_add as the dealloc callback
-// data -- an instance of Subscriber
-static void deleteObj(void* data)
-{
- delete (Subscriber*)data;
-}
-
-// This is given to linked_list_search() as the comparison callback
-// when the state manchine needs to process for particular subscriber
-// fromCaller -- caller provides this obj
-// fromList -- linked_list_search() function take this one from list
-static bool hasSubscriber(void* fromCaller, void* fromList)
-{
- Notification* notification = (Notification*)fromCaller;
- Subscriber* s1 = (Subscriber*)fromList;
-
- return s1->forMe(*notification);
-}
-
-// This is gvien to linked_list_search() to notify subscriber objs
-// when the state machine needs to inform all subscribers of resource
-// status changes, e.g. when resource is GRANTED.
-// fromCaller -- caller provides this ptr to a Notification obj.
-// fromList -- linked_list_search() function take this one from list
-static bool notifySubscriber(void* fromCaller, void* fromList)
-{
- Notification* notification = (Notification*)fromCaller;
- Subscriber* s1 = (Subscriber*)fromList;
-
- // we notify every subscriber indiscriminatively
- // each subscriber decides if this notification is interesting.
- return s1->notifyRsrcStatus(*notification) &&
- // if we do not want to delete the subscriber from the
- // the list, we must set this to false so this function
- // returns false
- notification->postNotifyDelete;
-}
-
-//======================================================================
-// Notification
-//======================================================================
-const int Notification::BROADCAST_ALL = 0x80000000;
-const int Notification::BROADCAST_ACTIVE = 0x80000001;
-const int Notification::BROADCAST_INACTIVE = 0x80000002;
-const unsigned char DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4;
-const unsigned int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500;
-//======================================================================
-// Subscriber: BITSubscriber / ATLSubscriber / WIFISubscriber
-//======================================================================
-bool Subscriber::forMe(Notification ¬ification)
-{
- if (NULL != notification.rcver) {
- return equals(notification.rcver);
- } else {
- return Notification::BROADCAST_ALL == notification.groupID ||
- (Notification::BROADCAST_ACTIVE == notification.groupID &&
- !isInactive()) ||
- (Notification::BROADCAST_INACTIVE == notification.groupID &&
- isInactive());
- }
-}
-bool BITSubscriber::equals(const Subscriber *s) const
-{
- BITSubscriber* bitS = (BITSubscriber*)s;
-
- return (ID == bitS->ID &&
- (INADDR_NONE != (unsigned int)ID ||
- 0 == strncmp(mIPv6Addr, bitS->mIPv6Addr, sizeof(mIPv6Addr))));
-}
-
-bool BITSubscriber::notifyRsrcStatus(Notification ¬ification)
-{
- bool notify = forMe(notification);
-
- if (notify) {
- switch(notification.rsrcStatus)
- {
- case RSRC_UNSUBSCRIBE:
- case RSRC_RELEASED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
- GPSONE_LOC_API_IF_RELEASE_SUCCESS);
- break;
- case RSRC_DENIED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
- GPSONE_LOC_API_IF_FAILURE);
- break;
- case RSRC_GRANTED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
- GPSONE_LOC_API_IF_REQUEST_SUCCESS);
- break;
- default:
- notify = false;
- }
- }
-
- return notify;
-}
-
-bool ATLSubscriber::notifyRsrcStatus(Notification ¬ification)
-{
- bool notify = forMe(notification);
-
- if (notify) {
- switch(notification.rsrcStatus)
- {
- case RSRC_UNSUBSCRIBE:
- case RSRC_RELEASED:
- ((LocEngAdapter*)mLocAdapter)->atlCloseStatus(ID, 1);
- break;
- case RSRC_DENIED:
- {
- AGpsExtType type = mBackwardCompatibleMode ?
- LOC_AGPS_TYPE_INVALID : mStateMachine->getType();
- ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 0,
- (char*)mStateMachine->getAPN(),
- mStateMachine->getBearer(),
- type);
- }
- break;
- case RSRC_GRANTED:
- {
- AGpsExtType type = mBackwardCompatibleMode ?
- LOC_AGPS_TYPE_INVALID : mStateMachine->getType();
- ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 1,
- (char*)mStateMachine->getAPN(),
- mStateMachine->getBearer(),
- type);
- }
- break;
- default:
- notify = false;
- }
- }
-
- return notify;
-}
-
-bool WIFISubscriber::notifyRsrcStatus(Notification ¬ification)
-{
- bool notify = forMe(notification);
-
- if (notify) {
- switch(notification.rsrcStatus)
- {
- case RSRC_UNSUBSCRIBE:
- break;
- case RSRC_RELEASED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- senderId,
- GPSONE_LOC_API_IF_RELEASE_SUCCESS);
- break;
- case RSRC_DENIED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- senderId,
- GPSONE_LOC_API_IF_FAILURE);
- break;
- case RSRC_GRANTED:
- loc_eng_dmn_conn_loc_api_server_data_conn(
- senderId,
- GPSONE_LOC_API_IF_REQUEST_SUCCESS);
- break;
- default:
- notify = false;
- }
- }
-
- return notify;
-}
-bool DSSubscriber::notifyRsrcStatus(Notification ¬ification)
-{
- bool notify = forMe(notification);
- LOC_LOGD("DSSubscriber::notifyRsrcStatus. notify:%d \n",(int)(notify));
- if(notify) {
- switch(notification.rsrcStatus) {
- case RSRC_UNSUBSCRIBE:
- case RSRC_RELEASED:
- case RSRC_DENIED:
- case RSRC_GRANTED:
- ((DSStateMachine *)mStateMachine)->informStatus(notification.rsrcStatus, ID);
- break;
- default:
- notify = false;
- }
- }
- return notify;
-}
-void DSSubscriber :: setInactive()
-{
- mIsInactive = true;
- ((DSStateMachine *)mStateMachine)->informStatus(RSRC_UNSUBSCRIBE, ID);
-}
-//======================================================================
-// AgpsState: AgpsReleasedState / AgpsPendingState / AgpsAcquiredState
-//======================================================================
-
-// AgpsReleasedState
-class AgpsReleasedState : public AgpsState
-{
- friend class AgpsStateMachine;
-
- inline AgpsReleasedState(AgpsStateMachine* stateMachine) :
- AgpsState(stateMachine)
- { mReleasedState = this; }
-
- inline ~AgpsReleasedState() {}
-public:
- virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
- inline virtual char* whoami() {return (char*)"AgpsReleasedState";}
-};
-
-AgpsState* AgpsReleasedState::onRsrcEvent(AgpsRsrcStatus event, void* data)
-{
- LOC_LOGD("AgpsReleasedState::onRsrcEvent; event:%d\n", (int)event);
- if (mStateMachine->hasSubscribers()) {
- LOC_LOGE("Error: %s subscriber list not empty!!!", whoami());
- // I don't know how to recover from it. I am adding this rather
- // for debugging purpose.
- }
-
- AgpsState* nextState = this;
- switch (event)
- {
- case RSRC_SUBSCRIBE:
- {
- // no notification until we get RSRC_GRANTED
- // but we need to add subscriber to the list
- mStateMachine->addSubscriber((Subscriber*)data);
- // request from connecivity service for NIF
- //The if condition is added so that if the data call setup fails
- //for DS State Machine, we want to retry in released state.
- //for AGps State Machine, sendRsrcRequest() will always return success
- if(!mStateMachine->sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)) {
- // move the state to PENDING
- nextState = mPendingState;
- }
- }
- break;
-
- case RSRC_UNSUBSCRIBE:
- {
- // the list should really be empty, nothing to remove.
- // but we might as well just tell the client it is
- // unsubscribed. False tolerance, right?
- Subscriber* subscriber = (Subscriber*) data;
- Notification notification(subscriber, event, false);
- subscriber->notifyRsrcStatus(notification);
- }
- // break;
- case RSRC_GRANTED:
- case RSRC_RELEASED:
- case RSRC_DENIED:
- default:
- LOC_LOGW("%s: unrecognized event %d", whoami(), event);
- // no state change.
- break;
- }
-
- LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
- whoami(), nextState->whoami(), event);
- return nextState;
-}
-
-// AgpsPendingState
-class AgpsPendingState : public AgpsState
-{
- friend class AgpsStateMachine;
-
- inline AgpsPendingState(AgpsStateMachine* stateMachine) :
- AgpsState(stateMachine)
- { mPendingState = this; }
-
- inline ~AgpsPendingState() {}
-public:
- virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
- inline virtual char* whoami() {return (char*)"AgpsPendingState";}
-};
-
-AgpsState* AgpsPendingState::onRsrcEvent(AgpsRsrcStatus event, void* data)
-{
- AgpsState* nextState = this;;
- LOC_LOGD("AgpsPendingState::onRsrcEvent; event:%d\n", (int)event);
- switch (event)
- {
- case RSRC_SUBSCRIBE:
- {
- // already requested for NIF resource,
- // do nothing until we get RSRC_GRANTED indication
- // but we need to add subscriber to the list
- mStateMachine->addSubscriber((Subscriber*)data);
- // no state change.
- }
- break;
-
- case RSRC_UNSUBSCRIBE:
- {
- Subscriber* subscriber = (Subscriber*) data;
- if (subscriber->waitForCloseComplete()) {
- subscriber->setInactive();
- } else {
- // auto notify this subscriber of the unsubscribe
- Notification notification(subscriber, event, true);
- mStateMachine->notifySubscribers(notification);
- }
-
- // now check if there is any subscribers left
- if (!mStateMachine->hasSubscribers()) {
- // no more subscribers, move to RELEASED state
- nextState = mReleasedState;
-
- // tell connecivity service we can release NIF
- mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN);
- } else if (!mStateMachine->hasActiveSubscribers()) {
- // only inactive subscribers, move to RELEASING state
- nextState = mReleasingState;
-
- // tell connecivity service we can release NIF
- mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN);
- }
- }
- break;
-
- case RSRC_GRANTED:
- {
- nextState = mAcquiredState;
- Notification notification(Notification::BROADCAST_ACTIVE, event, false);
- // notify all subscribers NIF resource GRANTED
- // by setting false, we keep subscribers on the linked list
- mStateMachine->notifySubscribers(notification);
- }
- break;
-
- case RSRC_RELEASED:
- // no state change.
- // we are expecting either GRANTED or DENIED. Handling RELEASED
- // may like break our state machine in race conditions.
- break;
-
- case RSRC_DENIED:
- {
- nextState = mReleasedState;
- Notification notification(Notification::BROADCAST_ALL, event, true);
- // notify all subscribers NIF resource RELEASED or DENIED
- // by setting true, we remove subscribers from the linked list
- mStateMachine->notifySubscribers(notification);
- }
- break;
-
- default:
- LOC_LOGE("%s: unrecognized event %d", whoami(), event);
- // no state change.
- }
-
- LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
- whoami(), nextState->whoami(), event);
- return nextState;
-}
-
-
-class AgpsAcquiredState : public AgpsState
-{
- friend class AgpsStateMachine;
-
- inline AgpsAcquiredState(AgpsStateMachine* stateMachine) :
- AgpsState(stateMachine)
- { mAcquiredState = this; }
-
- inline ~AgpsAcquiredState() {}
-public:
- virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
- inline virtual char* whoami() { return (char*)"AgpsAcquiredState"; }
-};
-
-
-AgpsState* AgpsAcquiredState::onRsrcEvent(AgpsRsrcStatus event, void* data)
-{
- AgpsState* nextState = this;
- LOC_LOGD("AgpsAcquiredState::onRsrcEvent; event:%d\n", (int)event);
- switch (event)
- {
- case RSRC_SUBSCRIBE:
- {
- // we already have the NIF resource, simply notify subscriber
- Subscriber* subscriber = (Subscriber*) data;
- // we have rsrc in hand, so grant it right away
- Notification notification(subscriber, RSRC_GRANTED, false);
- subscriber->notifyRsrcStatus(notification);
- // add subscriber to the list
- mStateMachine->addSubscriber(subscriber);
- // no state change.
- }
- break;
-
- case RSRC_UNSUBSCRIBE:
- {
- Subscriber* subscriber = (Subscriber*) data;
- if (subscriber->waitForCloseComplete()) {
- subscriber->setInactive();
- } else {
- // auto notify this subscriber of the unsubscribe
- Notification notification(subscriber, event, true);
- mStateMachine->notifySubscribers(notification);
- }
-
- // now check if there is any subscribers left
- if (!mStateMachine->hasSubscribers()) {
- // no more subscribers, move to RELEASED state
- nextState = mReleasedState;
-
- // tell connecivity service we can release NIF
- mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN);
- } else if (!mStateMachine->hasActiveSubscribers()) {
- // only inactive subscribers, move to RELEASING state
- nextState = mReleasingState;
-
- // tell connecivity service we can release NIF
- mStateMachine->sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN);
- }
- }
- break;
-
- case RSRC_GRANTED:
- LOC_LOGW("%s: %d, RSRC_GRANTED already received", whoami(), event);
- // no state change.
- break;
-
- case RSRC_RELEASED:
- {
- LOC_LOGW("%s: %d, a force rsrc release", whoami(), event);
- nextState = mReleasedState;
- Notification notification(Notification::BROADCAST_ALL, event, true);
- // by setting true, we remove subscribers from the linked list
- mStateMachine->notifySubscribers(notification);
- }
- break;
-
- case RSRC_DENIED:
- // no state change.
- // we are expecting RELEASED. Handling DENIED
- // may like break our state machine in race conditions.
- break;
-
- default:
- LOC_LOGE("%s: unrecognized event %d", whoami(), event);
- // no state change.
- }
-
- LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
- whoami(), nextState->whoami(), event);
- return nextState;
-}
-
-// AgpsPendingState
-class AgpsReleasingState : public AgpsState
-{
- friend class AgpsStateMachine;
-
- inline AgpsReleasingState(AgpsStateMachine* stateMachine) :
- AgpsState(stateMachine)
- { mReleasingState = this; }
-
- inline ~AgpsReleasingState() {}
-public:
- virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data);
- inline virtual char* whoami() {return (char*)"AgpsReleasingState";}
-};
-
-AgpsState* AgpsReleasingState::onRsrcEvent(AgpsRsrcStatus event, void* data)
-{
- AgpsState* nextState = this;;
- LOC_LOGD("AgpsReleasingState::onRsrcEvent; event:%d\n", (int)event);
-
- switch (event)
- {
- case RSRC_SUBSCRIBE:
- {
- // already requested for NIF resource,
- // do nothing until we get RSRC_GRANTED indication
- // but we need to add subscriber to the list
- mStateMachine->addSubscriber((Subscriber*)data);
- // no state change.
- }
- break;
-
- case RSRC_UNSUBSCRIBE:
- {
- Subscriber* subscriber = (Subscriber*) data;
- if (subscriber->waitForCloseComplete()) {
- subscriber->setInactive();
- } else {
- // auto notify this subscriber of the unsubscribe
- Notification notification(subscriber, event, true);
- mStateMachine->notifySubscribers(notification);
- }
-
- // now check if there is any subscribers left
- if (!mStateMachine->hasSubscribers()) {
- // no more subscribers, move to RELEASED state
- nextState = mReleasedState;
- }
- }
- break;
-
- case RSRC_DENIED:
- // A race condition subscriber unsubscribes before AFW denies resource.
- case RSRC_RELEASED:
- {
- nextState = mAcquiredState;
- Notification notification(Notification::BROADCAST_INACTIVE, event, true);
- // notify all subscribers that are active NIF resource RELEASE
- // by setting false, we keep subscribers on the linked list
- mStateMachine->notifySubscribers(notification);
-
- if (mStateMachine->hasActiveSubscribers()) {
- nextState = mPendingState;
- // request from connecivity service for NIF
- mStateMachine->sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN);
- } else {
- nextState = mReleasedState;
- }
- }
- break;
-
- case RSRC_GRANTED:
- default:
- LOC_LOGE("%s: unrecognized event %d", whoami(), event);
- // no state change.
- }
-
- LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d",
- whoami(), nextState->whoami(), event);
- return nextState;
-}
-//======================================================================
-//Servicer
-//======================================================================
-Servicer* Servicer :: getServicer(servicerType type, void *cb_func)
-{
- LOC_LOGD(" Enter getServicer type:%d\n", (int)type);
- switch(type) {
- case servicerTypeNoCbParam:
- return (new Servicer(cb_func));
- case servicerTypeExt:
- return (new ExtServicer(cb_func));
- case servicerTypeAgps:
- return (new AGpsServicer(cb_func));
- default:
- return NULL;
- }
-}
-
-int Servicer :: requestRsrc(void *cb_data)
-{
- callback();
- return 0;
-}
-
-int ExtServicer :: requestRsrc(void *cb_data)
-{
- int ret=-1;
- LOC_LOGD("Enter ExtServicer :: requestRsrc\n");
- ret = callbackExt(cb_data);
- LOC_LOGD("Exit ExtServicer :: requestRsrc\n");
- return(ret);
-}
-
-int AGpsServicer :: requestRsrc(void *cb_data)
-{
- callbackAGps((LocAGpsStatus *)cb_data);
- return 0;
-}
-
-//======================================================================
-// AgpsStateMachine
-//======================================================================
-
-AgpsStateMachine::AgpsStateMachine(servicerType servType,
- void *cb_func,
- AGpsExtType type,
- bool enforceSingleSubscriber) :
- mStatePtr(new AgpsReleasedState(this)),mType(type),
- mAPN(NULL),
- mAPNLen(0),
- mBearer(AGPS_APN_BEARER_INVALID),
- mEnforceSingleSubscriber(enforceSingleSubscriber),
- mServicer(Servicer :: getServicer(servType, (void *)cb_func))
-{
- linked_list_init(&mSubscribers);
-
- // setting up mReleasedState
- mStatePtr->mPendingState = new AgpsPendingState(this);
- mStatePtr->mAcquiredState = new AgpsAcquiredState(this);
- mStatePtr->mReleasingState = new AgpsReleasingState(this);
-
- // setting up mAcquiredState
- mStatePtr->mAcquiredState->mReleasedState = mStatePtr;
- mStatePtr->mAcquiredState->mPendingState = mStatePtr->mPendingState;
- mStatePtr->mAcquiredState->mReleasingState = mStatePtr->mReleasingState;
-
- // setting up mPendingState
- mStatePtr->mPendingState->mAcquiredState = mStatePtr->mAcquiredState;
- mStatePtr->mPendingState->mReleasedState = mStatePtr;
- mStatePtr->mPendingState->mReleasingState = mStatePtr->mReleasingState;
-
- // setting up mReleasingState
- mStatePtr->mReleasingState->mReleasedState = mStatePtr;
- mStatePtr->mReleasingState->mPendingState = mStatePtr->mPendingState;
- mStatePtr->mReleasingState->mAcquiredState = mStatePtr->mAcquiredState;
-}
-
-AgpsStateMachine::~AgpsStateMachine()
-{
- dropAllSubscribers();
-
- // free the 3 states. We must read out all 3 pointers first.
- // Otherwise we run the risk of getting pointers from already
- // freed memory.
- AgpsState* acquiredState = mStatePtr->mAcquiredState;
- AgpsState* releasedState = mStatePtr->mReleasedState;
- AgpsState* pendindState = mStatePtr->mPendingState;
- AgpsState* releasingState = mStatePtr->mReleasingState;
-
- delete acquiredState;
- delete releasedState;
- delete pendindState;
- delete releasingState;
- delete mServicer;
- linked_list_destroy(&mSubscribers);
-
- if (NULL != mAPN) {
- delete[] mAPN;
- mAPN = NULL;
- }
-}
-
-void AgpsStateMachine::setAPN(const char* apn, unsigned int len)
-{
- if (NULL != mAPN) {
- delete mAPN;
- }
-
- if (NULL != apn) {
- mAPN = new char[len+1];
- memcpy(mAPN, apn, len);
- mAPN[len] = NULL;
-
- mAPNLen = len;
- } else {
- mAPN = NULL;
- mAPNLen = 0;
- }
-}
-
-void AgpsStateMachine::onRsrcEvent(AgpsRsrcStatus event)
-{
- switch (event)
- {
- case RSRC_GRANTED:
- case RSRC_RELEASED:
- case RSRC_DENIED:
- mStatePtr = mStatePtr->onRsrcEvent(event, NULL);
- break;
- default:
- LOC_LOGW("AgpsStateMachine: unrecognized event %d", event);
- break;
- }
-}
-
-void AgpsStateMachine::notifySubscribers(Notification& notification) const
-{
- if (notification.postNotifyDelete) {
- // just any non NULL value to get started
- Subscriber* s = (Subscriber*)~0;
- while (NULL != s) {
- s = NULL;
- // if the last param sets to true, _search will delete
- // the node from the list for us. But the problem is
- // once that is done, _search returns, leaving the
- // rest of the list unprocessed. So we need a loop.
- linked_list_search(mSubscribers, (void**)&s, notifySubscriber,
- (void*)¬ification, true);
- delete s;
- }
- } else {
- // no loop needed if it the last param sets to false, which
- // mean nothing gets deleted from the list.
- linked_list_search(mSubscribers, NULL, notifySubscriber,
- (void*)¬ification, false);
- }
-}
-
-void AgpsStateMachine::addSubscriber(Subscriber* subscriber) const
-{
- Subscriber* s = NULL;
- Notification notification((const Subscriber*)subscriber);
- linked_list_search(mSubscribers, (void**)&s,
- hasSubscriber, (void*)¬ification, false);
-
- if (NULL == s) {
- linked_list_add(mSubscribers, subscriber->clone(), deleteObj);
- }
-}
-
-int AgpsStateMachine::sendRsrcRequest(LocAGpsStatusValue action) const
-{
- Subscriber* s = NULL;
- Notification notification(Notification::BROADCAST_ACTIVE);
- linked_list_search(mSubscribers, (void**)&s, hasSubscriber,
- (void*)¬ification, false);
-
- if ((NULL == s) == (LOC_GPS_RELEASE_AGPS_DATA_CONN == action)) {
- AGpsExtStatus nifRequest;
- nifRequest.size = sizeof(nifRequest);
- nifRequest.type = mType;
- nifRequest.status = action;
-
- if (s == NULL) {
- nifRequest.ipv4_addr = INADDR_NONE;
- memset(&nifRequest.addr, 0, sizeof(nifRequest.addr));
- nifRequest.ssid[0] = '\0';
- nifRequest.password[0] = '\0';
- } else {
- s->setIPAddresses(nifRequest.addr);
- s->setWifiInfo(nifRequest.ssid, nifRequest.password);
- }
-
- CALLBACK_LOG_CALLFLOW("agps_cb", %s, loc_get_agps_status_name(action));
- mServicer->requestRsrc((void *)&nifRequest);
- }
- return 0;
-}
-
-void AgpsStateMachine::subscribeRsrc(Subscriber *subscriber)
-{
- if (mEnforceSingleSubscriber && hasSubscribers()) {
- Notification notification(Notification::BROADCAST_ALL, RSRC_DENIED, true);
- notifySubscriber(¬ification, subscriber);
- } else {
- mStatePtr = mStatePtr->onRsrcEvent(RSRC_SUBSCRIBE, (void*)subscriber);
- }
-}
-
-bool AgpsStateMachine::unsubscribeRsrc(Subscriber *subscriber)
-{
- Subscriber* s = NULL;
- Notification notification((const Subscriber*)subscriber);
- linked_list_search(mSubscribers, (void**)&s,
- hasSubscriber, (void*)¬ification, false);
-
- if (NULL != s) {
- mStatePtr = mStatePtr->onRsrcEvent(RSRC_UNSUBSCRIBE, (void*)s);
- return true;
- }
- return false;
-}
-
-bool AgpsStateMachine::hasActiveSubscribers() const
-{
- Subscriber* s = NULL;
- Notification notification(Notification::BROADCAST_ACTIVE);
- linked_list_search(mSubscribers, (void**)&s,
- hasSubscriber, (void*)¬ification, false);
- return NULL != s;
-}
-
-//======================================================================
-// DSStateMachine
-//======================================================================
-void delay_callback(void *callbackData, int result)
-{
- if(callbackData) {
- DSStateMachine *DSSMInstance = (DSStateMachine *)callbackData;
- DSSMInstance->retryCallback();
- }
- else {
- LOC_LOGE(" NULL argument received. Failing.\n");
- goto err;
- }
-err:
- return;
-}
-
-DSStateMachine :: DSStateMachine(servicerType type, void *cb_func,
- LocEngAdapter* adapterHandle):
- AgpsStateMachine(type, cb_func, LOC_AGPS_TYPE_INVALID,false),
- mLocAdapter(adapterHandle)
-{
- LOC_LOGD("%s:%d]: New DSStateMachine\n", __func__, __LINE__);
- mRetries = 0;
-}
-
-void DSStateMachine :: retryCallback(void)
-{
- DSSubscriber *subscriber = NULL;
- Notification notification(Notification::BROADCAST_ACTIVE);
- linked_list_search(mSubscribers, (void**)&subscriber, hasSubscriber,
- (void*)¬ification, false);
- if(subscriber)
- mLocAdapter->requestSuplES(subscriber->ID);
- else
- LOC_LOGE("DSStateMachine :: retryCallback: No subscriber found." \
- "Cannot retry data call\n");
- return;
-}
-
-int DSStateMachine :: sendRsrcRequest(LocAGpsStatusValue action) const
-{
- DSSubscriber* s = NULL;
- dsCbData cbData;
- int ret=-1;
- int connHandle=-1;
- LOC_LOGD("Enter DSStateMachine :: sendRsrcRequest\n");
- Notification notification(Notification::BROADCAST_ACTIVE);
- linked_list_search(mSubscribers, (void**)&s, hasSubscriber,
- (void*)¬ification, false);
- if(s) {
- connHandle = s->ID;
- LOC_LOGD("DSStateMachine :: sendRsrcRequest - subscriber found\n");
- }
- else
- LOC_LOGD("DSStateMachine :: sendRsrcRequest - No subscriber found\n");
-
- cbData.action = action;
- cbData.mAdapter = mLocAdapter;
- ret = mServicer->requestRsrc((void *)&cbData);
- //Only the request to start data call returns a success/failure
- //The request to stop data call will always succeed
- //Hence, the below block will only be executed when the
- //request to start the data call fails
- switch(ret) {
- case LOC_API_ADAPTER_ERR_ENGINE_BUSY:
- LOC_LOGD("DSStateMachine :: sendRsrcRequest - Failure returned: %d\n",ret);
- ((DSStateMachine *)this)->incRetries();
- if(mRetries > MAX_START_DATA_CALL_RETRIES) {
- LOC_LOGE(" Failed to start Data call. Fallback to normal ATL SUPL\n");
- informStatus(RSRC_DENIED, connHandle);
- }
- else {
- if(loc_timer_start(DATA_CALL_RETRY_DELAY_MSEC, delay_callback, (void *)this)) {
- LOC_LOGE("Error: Could not start delay thread\n");
- ret = -1;
- goto err;
- }
- }
- break;
- case LOC_API_ADAPTER_ERR_UNSUPPORTED:
- LOC_LOGE("No profile found for emergency call. Fallback to normal SUPL ATL\n");
- informStatus(RSRC_DENIED, connHandle);
- break;
- case LOC_API_ADAPTER_ERR_SUCCESS:
- LOC_LOGD("%s:%d]: Request to start data call sent\n", __func__, __LINE__);
- break;
- case -1:
- //One of the ways this case can be encountered is if the callback function
- //receives a null argument, it just exits with -1 error
- LOC_LOGE("Error: Something went wrong somewhere. Falling back to normal SUPL ATL\n");
- informStatus(RSRC_DENIED, connHandle);
- break;
- default:
- LOC_LOGE("%s:%d]: Unrecognized return value\n", __func__, __LINE__);
- }
-err:
- LOC_LOGD("EXIT DSStateMachine :: sendRsrcRequest; ret = %d\n", ret);
- return ret;
-}
-
-void DSStateMachine :: onRsrcEvent(AgpsRsrcStatus event)
-{
- void* currState = (void *)mStatePtr;
- LOC_LOGD("Enter DSStateMachine :: onRsrcEvent. event = %d\n", (int)event);
- switch (event)
- {
- case RSRC_GRANTED:
- LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_GRANTED\n");
- mStatePtr = mStatePtr->onRsrcEvent(event, NULL);
- break;
- case RSRC_RELEASED:
- LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_RELEASED\n");
- mStatePtr = mStatePtr->onRsrcEvent(event, NULL);
- //To handle the case where we get a RSRC_RELEASED in
- //pending state, we translate that to a RSRC_DENIED state
- //since the callback from DSI is either RSRC_GRANTED or RSRC_RELEASED
- //for when the call is connected or disconnected respectively.
- if((void *)mStatePtr != currState)
- break;
- else {
- event = RSRC_DENIED;
- LOC_LOGE(" Switching event to RSRC_DENIED\n");
- }
- case RSRC_DENIED:
- mStatePtr = mStatePtr->onRsrcEvent(event, NULL);
- break;
- default:
- LOC_LOGW("AgpsStateMachine: unrecognized event %d", event);
- break;
- }
- LOC_LOGD("Exit DSStateMachine :: onRsrcEvent. event = %d\n", (int)event);
-}
-
-void DSStateMachine :: informStatus(AgpsRsrcStatus status, int ID) const
-{
- LOC_LOGD("DSStateMachine :: informStatus. Status=%d\n",(int)status);
- switch(status) {
- case RSRC_UNSUBSCRIBE:
- mLocAdapter->atlCloseStatus(ID, 1);
- break;
- case RSRC_RELEASED:
- mLocAdapter->closeDataCall();
- break;
- case RSRC_DENIED:
- ((DSStateMachine *)this)->mRetries = 0;
- mLocAdapter->requestATL(ID, LOC_AGPS_TYPE_SUPL);
- break;
- case RSRC_GRANTED:
- mLocAdapter->atlOpenStatus(ID, 1,
- NULL,
- AGPS_APN_BEARER_INVALID,
- LOC_AGPS_TYPE_INVALID);
- break;
- default:
- LOC_LOGW("DSStateMachine :: informStatus - unknown status");
- }
- return;
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_agps.h b/msm8998/loc_api/libloc_api_50001/loc_eng_agps.h
deleted file mode 100644
index ff879f4..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_agps.h
+++ /dev/null
@@ -1,434 +0,0 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef __LOC_ENG_AGPS_H__
-#define __LOC_ENG_AGPS_H__
-
-#include <stdbool.h>
-#include <ctype.h>
-#include <string.h>
-#include <arpa/inet.h>
-#include <gps_extended.h>
-#include <loc_core_log.h>
-#include <linked_list.h>
-#include <loc_timer.h>
-#include <LocEngAdapter.h>
-#include <platform_lib_includes.h>
-#if defined(USE_GLIB) && !defined(OFF_TARGET)
-#include <glib.h>
-#endif /* USE_GLIB */
-
-// forward declaration
-class AgpsStateMachine;
-struct Subscriber;
-
-// NIF resource events
-typedef enum {
- RSRC_SUBSCRIBE,
- RSRC_UNSUBSCRIBE,
- RSRC_GRANTED,
- RSRC_RELEASED,
- RSRC_DENIED,
- RSRC_STATUS_MAX
-} AgpsRsrcStatus;
-
-typedef enum {
- servicerTypeNoCbParam,
- servicerTypeAgps,
- servicerTypeExt
-}servicerType;
-
-//DS Callback struct
-typedef struct {
- LocEngAdapter *mAdapter;
- LocAGpsStatusValue action;
-}dsCbData;
-
-// information bundle for subscribers
-struct Notification {
- // goes to every subscriber
- static const int BROADCAST_ALL;
- // goes to every ACTIVE subscriber
- static const int BROADCAST_ACTIVE;
- // goes to every INACTIVE subscriber
- static const int BROADCAST_INACTIVE;
-
- // go to a specific subscriber
- const Subscriber* rcver;
- // broadcast
- const int groupID;
- // the new resource status event
- const AgpsRsrcStatus rsrcStatus;
- // should the subscriber be deleted after the notification
- const bool postNotifyDelete;
-
- // convenient constructor
- inline Notification(const int broadcast,
- const AgpsRsrcStatus status,
- const bool deleteAfterwards) :
- rcver(NULL), groupID(broadcast), rsrcStatus(status),
- postNotifyDelete(deleteAfterwards) {}
-
- // convenient constructor
- inline Notification(const Subscriber* subscriber,
- const AgpsRsrcStatus status,
- const bool deleteAfterwards) :
- rcver(subscriber), groupID(-1), rsrcStatus(status),
- postNotifyDelete(deleteAfterwards) {}
-
- // convenient constructor
- inline Notification(const int broadcast) :
- rcver(NULL), groupID(broadcast), rsrcStatus(RSRC_STATUS_MAX),
- postNotifyDelete(false) {}
-
- // convenient constructor
- inline Notification(const Subscriber* subscriber) :
- rcver(subscriber), groupID(-1), rsrcStatus(RSRC_STATUS_MAX),
- postNotifyDelete(false) {}
-};
-
-class AgpsState {
- // allows AgpsStateMachine to access private data
- // no class members are public. We don't want
- // anyone but state machine to use state.
- friend class AgpsStateMachine;
- friend class DSStateMachine;
- // state transitions are done here.
- // Each state implements its own transitions (of course).
- inline virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data) = 0;
-
-protected:
- // handle back to state machine
- const AgpsStateMachine* mStateMachine;
- // each state has pointers to all 3 states
- // one of which is to itself.
- AgpsState* mReleasedState;
- AgpsState* mAcquiredState;
- AgpsState* mPendingState;
- AgpsState* mReleasingState;
-
- inline AgpsState(const AgpsStateMachine *stateMachine) :
- mStateMachine(stateMachine),
- mReleasedState(NULL),
- mAcquiredState(NULL),
- mPendingState(NULL),
- mReleasingState(NULL) {}
- virtual ~AgpsState() {}
-
-public:
- // for logging purpose
- inline virtual char* whoami() = 0;
-};
-
-class Servicer {
- void (*callback)(void);
-public:
- static Servicer* getServicer(servicerType type, void *cb_func);
- virtual int requestRsrc(void *cb_data);
- Servicer() {}
- Servicer(void *cb_func)
- { callback = (void(*)(void))(cb_func); }
- virtual ~Servicer(){}
- inline virtual char *whoami() {return (char*)"Servicer";}
-};
-
-class ExtServicer : public Servicer {
- int (*callbackExt)(void *cb_data);
-public:
- int requestRsrc(void *cb_data);
- ExtServicer() {}
- ExtServicer(void *cb_func)
- { callbackExt = (int(*)(void *))(cb_func); }
- virtual ~ExtServicer(){}
- inline virtual char *whoami() {return (char*)"ExtServicer";}
-};
-
-class AGpsServicer : public Servicer {
- void (*callbackAGps)(LocAGpsStatus* status);
-public:
- int requestRsrc(void *cb_data);
- AGpsServicer() {}
- AGpsServicer(void *cb_func)
- { callbackAGps = (void(*)(LocAGpsStatus *))(cb_func); }
- virtual ~AGpsServicer(){}
- inline virtual char *whoami() {return (char*)"AGpsServicer";}
-};
-
-class AgpsStateMachine {
-protected:
- // a linked list of subscribers.
- void* mSubscribers;
- //handle to whoever provides the service
- Servicer *mServicer;
- // allows AgpsState to access private data
- // each state is really internal data to the
- // state machine, so it should be able to
- // access anything within the state machine.
- friend class AgpsState;
- // pointer to the current state.
- AgpsState* mStatePtr;
-private:
- // NIF type: AGNSS or INTERNET.
- const AGpsExtType mType;
- // apn to the NIF. Each state machine tracks
- // resource state of a particular NIF. For each
- // NIF, there is also an active APN.
- char* mAPN;
- // for convenience, we don't do strlen each time.
- unsigned int mAPNLen;
- // bear
- AGpsBearerType mBearer;
- // ipv4 address for routing
- bool mEnforceSingleSubscriber;
-
-public:
- AgpsStateMachine(servicerType servType, void *cb_func,
- AGpsExtType type, bool enforceSingleSubscriber);
- virtual ~AgpsStateMachine();
-
- // self explanatory methods below
- void setAPN(const char* apn, unsigned int len);
- inline const char* getAPN() const { return (const char*)mAPN; }
- inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; }
- inline AGpsBearerType getBearer() const { return mBearer; }
- inline AGpsExtType getType() const { return (AGpsExtType)mType; }
-
- // someone, a ATL client or BIT, is asking for NIF
- void subscribeRsrc(Subscriber *subscriber);
-
- // someone, a ATL client or BIT, is done with NIF
- bool unsubscribeRsrc(Subscriber *subscriber);
-
- // add a subscriber in the linked list, if not already there.
- void addSubscriber(Subscriber* subscriber) const;
-
- virtual void onRsrcEvent(AgpsRsrcStatus event);
-
- // put the data together and send the FW
- virtual int sendRsrcRequest(LocAGpsStatusValue action) const;
-
- //if list is empty, linked_list_empty returns 1
- //else if list is not empty, returns 0
- //so hasSubscribers() returns 1 if list is not empty
- //and returns 0 if list is empty
- inline bool hasSubscribers() const
- { return !linked_list_empty(mSubscribers); }
-
- bool hasActiveSubscribers() const;
-
- inline void dropAllSubscribers() const
- { linked_list_flush(mSubscribers); }
-
- // private. Only a state gets to call this.
- void notifySubscribers(Notification& notification) const;
-
-};
-
-class DSStateMachine : public AgpsStateMachine {
- static const unsigned char MAX_START_DATA_CALL_RETRIES;
- static const unsigned int DATA_CALL_RETRY_DELAY_MSEC;
- LocEngAdapter* mLocAdapter;
- unsigned char mRetries;
-public:
- DSStateMachine(servicerType type,
- void *cb_func,
- LocEngAdapter* adapterHandle);
- int sendRsrcRequest(LocAGpsStatusValue action) const;
- void onRsrcEvent(AgpsRsrcStatus event);
- void retryCallback();
- void informStatus(AgpsRsrcStatus status, int ID) const;
- inline void incRetries() {mRetries++;}
- inline virtual char *whoami() {return (char*)"DSStateMachine";}
-};
-
-// each subscriber is a AGPS client. In the case of ATL, there could be
-// multiple clients from modem. In the case of BIT, there is only one
-// cilent from BIT daemon.
-struct Subscriber {
- const uint32_t ID;
- const AgpsStateMachine* mStateMachine;
- inline Subscriber(const int id,
- const AgpsStateMachine* stateMachine) :
- ID(id), mStateMachine(stateMachine) {}
- inline virtual ~Subscriber() {}
-
- virtual void setIPAddresses(uint32_t &v4, char* v6) = 0;
- virtual void setIPAddresses(struct sockaddr_storage& addr) = 0;
- inline virtual void setWifiInfo(char* ssid, char* password)
- { ssid[0] = 0; password[0] = 0; }
-
- inline virtual bool equals(const Subscriber *s) const
- { return ID == s->ID; }
-
- // notifies a subscriber a new NIF resource status, usually
- // either GRANTE, DENIED, or RELEASED
- virtual bool notifyRsrcStatus(Notification ¬ification) = 0;
-
- virtual bool waitForCloseComplete() { return false; }
- virtual void setInactive() {}
- virtual bool isInactive() { return false; }
-
- virtual Subscriber* clone() = 0;
- // checks if this notification is for me, i.e.
- // either has my id, or has a broadcast id.
- bool forMe(Notification ¬ification);
-};
-
-// BITSubscriber, created with requests from BIT daemon
-struct BITSubscriber : public Subscriber {
- char mIPv6Addr[16];
-
- inline BITSubscriber(const AgpsStateMachine* stateMachine,
- unsigned int ipv4, char* ipv6) :
- Subscriber(ipv4, stateMachine)
- {
- if (NULL == ipv6) {
- mIPv6Addr[0] = 0;
- } else {
- memcpy(mIPv6Addr, ipv6, sizeof(mIPv6Addr));
- }
- }
-
- virtual bool notifyRsrcStatus(Notification ¬ification);
-
- inline virtual void setIPAddresses(uint32_t &v4, char* v6)
- { v4 = ID; memcpy(v6, mIPv6Addr, sizeof(mIPv6Addr)); }
-
- inline virtual void setIPAddresses(struct sockaddr_storage& addr)
- { addr.ss_family = AF_INET6;/*todo: convert mIPv6Addr into addr */ }
-
- virtual Subscriber* clone()
- {
- return new BITSubscriber(mStateMachine, ID, mIPv6Addr);
- }
-
- virtual bool equals(const Subscriber *s) const;
- inline virtual ~BITSubscriber(){}
-};
-
-// ATLSubscriber, created with requests from ATL
-struct ATLSubscriber : public Subscriber {
- const LocEngAdapter* mLocAdapter;
- const bool mBackwardCompatibleMode;
- inline ATLSubscriber(const int id,
- const AgpsStateMachine* stateMachine,
- const LocEngAdapter* adapter,
- const bool compatibleMode) :
- Subscriber(id, stateMachine), mLocAdapter(adapter),
- mBackwardCompatibleMode(compatibleMode){}
- virtual bool notifyRsrcStatus(Notification ¬ification);
-
- inline virtual void setIPAddresses(uint32_t &v4, char* v6)
- { v4 = INADDR_NONE; v6[0] = 0; }
-
- inline virtual void setIPAddresses(struct sockaddr_storage& addr)
- { addr.ss_family = AF_INET6; }
-
- inline virtual Subscriber* clone()
- {
- return new ATLSubscriber(ID, mStateMachine, mLocAdapter,
- mBackwardCompatibleMode);
- }
- inline virtual ~ATLSubscriber(){}
-};
-
-// WIFISubscriber, created with requests from MSAPM or QuIPC
-struct WIFISubscriber : public Subscriber {
- char * mSSID;
- char * mPassword;
- loc_if_req_sender_id_e_type senderId;
- bool mIsInactive;
- inline WIFISubscriber(const AgpsStateMachine* stateMachine,
- char * ssid, char * password, loc_if_req_sender_id_e_type sender_id) :
- Subscriber(sender_id, stateMachine),
- mSSID(NULL == ssid ? NULL : new char[SSID_BUF_SIZE]),
- mPassword(NULL == password ? NULL : new char[SSID_BUF_SIZE]),
- senderId(sender_id)
- {
- if (NULL != mSSID)
- strlcpy(mSSID, ssid, SSID_BUF_SIZE);
- if (NULL != mPassword)
- strlcpy(mPassword, password, SSID_BUF_SIZE);
- mIsInactive = false;
- }
-
- virtual bool notifyRsrcStatus(Notification ¬ification);
-
- inline virtual void setIPAddresses(uint32_t &v4, char* v6) {}
-
- inline virtual void setIPAddresses(struct sockaddr_storage& addr)
- { addr.ss_family = AF_INET6; }
-
- inline virtual void setWifiInfo(char* ssid, char* password)
- {
- if (NULL != mSSID)
- strlcpy(ssid, mSSID, SSID_BUF_SIZE);
- else
- ssid[0] = '\0';
- if (NULL != mPassword)
- strlcpy(password, mPassword, SSID_BUF_SIZE);
- else
- password[0] = '\0';
- }
-
- inline virtual bool waitForCloseComplete() { return true; }
-
- inline virtual void setInactive() { mIsInactive = true; }
- inline virtual bool isInactive() { return mIsInactive; }
-
- virtual Subscriber* clone()
- {
- return new WIFISubscriber(mStateMachine, mSSID, mPassword, senderId);
- }
- inline virtual ~WIFISubscriber(){}
-};
-
-struct DSSubscriber : public Subscriber {
- bool mIsInactive;
- inline DSSubscriber(const AgpsStateMachine *stateMachine,
- const int id) :
- Subscriber(id, stateMachine)
- {
- mIsInactive = false;
- }
- inline virtual void setIPAddresses(uint32_t &v4, char* v6) {}
- inline virtual void setIPAddresses(struct sockaddr_storage& addr)
- { addr.ss_family = AF_INET6; }
- virtual Subscriber* clone()
- {return new DSSubscriber(mStateMachine, ID);}
- virtual bool notifyRsrcStatus(Notification ¬ification);
- inline virtual bool waitForCloseComplete() { return true; }
- virtual void setInactive();
- inline virtual bool isInactive()
- { return mIsInactive; }
- inline virtual ~DSSubscriber(){}
- inline virtual char *whoami() {return (char*)"DSSubscriber";}
-};
-
-#endif //__LOC_ENG_AGPS_H__
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp
deleted file mode 100644
index 5510fc5..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <linux/stat.h>
-#include <fcntl.h>
-#include <linux/types.h>
-#include <unistd.h>
-#include <errno.h>
-#include <grp.h>
-#include <sys/stat.h>
-
-#include <platform_lib_includes.h>
-#include "loc_eng_dmn_conn_glue_msg.h"
-#include "loc_eng_dmn_conn_handler.h"
-#include "loc_eng_dmn_conn.h"
-#include "loc_eng_msg.h"
-
-static int loc_api_server_msgqid;
-static int loc_api_resp_msgqid;
-static int quipc_msgqid;
-static int msapm_msgqid;
-static int msapu_msgqid;
-
-static const char * global_loc_api_q_path = GPSONE_LOC_API_Q_PATH;
-static const char * global_loc_api_resp_q_path = GPSONE_LOC_API_RESP_Q_PATH;
-static const char * global_quipc_ctrl_q_path = QUIPC_CTRL_Q_PATH;
-static const char * global_msapm_ctrl_q_path = MSAPM_CTRL_Q_PATH;
-static const char * global_msapu_ctrl_q_path = MSAPU_CTRL_Q_PATH;
-
-static int loc_api_server_proc_init(void *context)
-{
- loc_api_server_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_q_path, O_RDWR);
- //change mode/group for the global_loc_api_q_path pipe
- int result = chmod (global_loc_api_q_path, 0660);
- if (result != 0)
- {
- LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_q_path, strerror(errno));
- }
-
- struct group * gps_group = getgrnam("gps");
- if (gps_group != NULL)
- {
- result = chown (global_loc_api_q_path, -1, gps_group->gr_gid);
- if (result != 0)
- {
- LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n",
- global_loc_api_q_path, gps_group->gr_gid, result, strerror(errno));
- }
- }
- else
- {
- LOC_LOGE("getgrnam for gps failed, error code = %d\n", errno);
- }
-
- loc_api_resp_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_resp_q_path, O_RDWR);
-
- //change mode/group for the global_loc_api_resp_q_path pipe
- result = chmod (global_loc_api_resp_q_path, 0660);
- if (result != 0)
- {
- LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_resp_q_path, strerror(errno));
- }
-
- if (gps_group != NULL)
- {
- result = chown (global_loc_api_resp_q_path, -1, gps_group->gr_gid);
- if (result != 0)
- {
- LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n",
- global_loc_api_resp_q_path,
- gps_group->gr_gid, result, strerror(errno));
- }
- }
-
- quipc_msgqid = loc_eng_dmn_conn_glue_msgget(global_quipc_ctrl_q_path, O_RDWR);
- msapm_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapm_ctrl_q_path , O_RDWR);
- msapu_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapu_ctrl_q_path , O_RDWR);
-
- LOC_LOGD("%s:%d] loc_api_server_msgqid = %d\n", __func__, __LINE__, loc_api_server_msgqid);
- return 0;
-}
-
-static int loc_api_server_proc_pre(void *context)
-{
- return 0;
-}
-
-static int loc_api_server_proc(void *context)
-{
- int length, sz;
- int result = 0;
- static int cnt = 0;
- struct ctrl_msgbuf * p_cmsgbuf;
- struct ctrl_msgbuf cmsg_resp;
-
- sz = sizeof(struct ctrl_msgbuf) + 256;
- p_cmsgbuf = (struct ctrl_msgbuf *) malloc(sz);
-
- if (!p_cmsgbuf) {
- LOC_LOGE("%s:%d] Out of memory\n", __func__, __LINE__);
- return -1;
- }
-
- cnt ++;
- LOC_LOGD("%s:%d] %d listening on %s...\n", __func__, __LINE__, cnt, (char *) context);
- length = loc_eng_dmn_conn_glue_msgrcv(loc_api_server_msgqid, p_cmsgbuf, sz);
- if (length <= 0) {
- free(p_cmsgbuf);
- LOC_LOGE("%s:%d] fail receiving msg from gpsone_daemon, retry later\n", __func__, __LINE__);
- usleep(1000);
- return -1;
- }
-
- LOC_LOGD("%s:%d] received ctrl_type = %d\n", __func__, __LINE__, p_cmsgbuf->ctrl_type);
- switch(p_cmsgbuf->ctrl_type) {
- case GPSONE_LOC_API_IF_REQUEST:
- result = loc_eng_dmn_conn_loc_api_server_if_request_handler(p_cmsgbuf, length);
- break;
-
- case GPSONE_LOC_API_IF_RELEASE:
- result = loc_eng_dmn_conn_loc_api_server_if_release_handler(p_cmsgbuf, length);
- break;
-
- case GPSONE_UNBLOCK:
- LOC_LOGD("%s:%d] GPSONE_UNBLOCK\n", __func__, __LINE__);
- break;
-
- default:
- LOC_LOGE("%s:%d] unsupported ctrl_type = %d\n",
- __func__, __LINE__, p_cmsgbuf->ctrl_type);
- break;
- }
-
- free(p_cmsgbuf);
- return 0;
-}
-
-static int loc_api_server_proc_post(void *context)
-{
- LOC_LOGD("%s:%d]\n", __func__, __LINE__);
- loc_eng_dmn_conn_glue_msgremove( global_loc_api_q_path, loc_api_server_msgqid);
- loc_eng_dmn_conn_glue_msgremove( global_loc_api_resp_q_path, loc_api_resp_msgqid);
- loc_eng_dmn_conn_glue_msgremove( global_quipc_ctrl_q_path, quipc_msgqid);
- loc_eng_dmn_conn_glue_msgremove( global_msapm_ctrl_q_path, msapm_msgqid);
- loc_eng_dmn_conn_glue_msgremove( global_msapu_ctrl_q_path, msapu_msgqid);
- return 0;
-}
-
-static int loc_eng_dmn_conn_unblock_proc(void)
-{
- struct ctrl_msgbuf cmsgbuf;
- cmsgbuf.ctrl_type = GPSONE_UNBLOCK;
- LOC_LOGD("%s:%d]\n", __func__, __LINE__);
- loc_eng_dmn_conn_glue_msgsnd(loc_api_server_msgqid, & cmsgbuf, sizeof(cmsgbuf));
- return 0;
-}
-
-static struct loc_eng_dmn_conn_thelper thelper;
-
-int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb,
- const char * loc_api_q_path, const char * resp_q_path, void *agps_handle)
-{
- int result;
-
- loc_api_handle = agps_handle;
-
- if (loc_api_q_path) global_loc_api_q_path = loc_api_q_path;
- if (resp_q_path) global_loc_api_resp_q_path = resp_q_path;
-
- result = loc_eng_dmn_conn_launch_thelper( &thelper,
- loc_api_server_proc_init,
- loc_api_server_proc_pre,
- loc_api_server_proc,
- loc_api_server_proc_post,
- create_thread_cb,
- (char *) global_loc_api_q_path);
- if (result != 0) {
- LOC_LOGE("%s:%d]\n", __func__, __LINE__);
- return -1;
- }
- return 0;
-}
-
-int loc_eng_dmn_conn_loc_api_server_unblock(void)
-{
- loc_eng_dmn_conn_unblock_thelper(&thelper);
- loc_eng_dmn_conn_unblock_proc();
- return 0;
-}
-
-int loc_eng_dmn_conn_loc_api_server_join(void)
-{
- loc_eng_dmn_conn_join_thelper(&thelper);
- return 0;
-}
-
-int loc_eng_dmn_conn_loc_api_server_data_conn(int sender_id, int status) {
- struct ctrl_msgbuf cmsgbuf;
- LOC_LOGD("%s:%d] quipc_msgqid = %d\n", __func__, __LINE__, quipc_msgqid);
- cmsgbuf.ctrl_type = GPSONE_LOC_API_RESPONSE;
- cmsgbuf.cmsg.cmsg_response.result = status;
- switch (sender_id) {
- case LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC: {
- LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC", __func__, __LINE__);
- if (loc_eng_dmn_conn_glue_msgsnd(quipc_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) {
- LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__);
- return -1;
- }
- break;
- }
- case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM: {
- LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM", __func__, __LINE__);
- if (loc_eng_dmn_conn_glue_msgsnd(msapm_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) {
- LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__);
- return -1;
- }
- break;
- }
- case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU: {
- LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU", __func__, __LINE__);
- if (loc_eng_dmn_conn_glue_msgsnd(msapu_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) {
- LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__);
- return -1;
- }
- break;
- }
- case LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON: {
- LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON", __func__, __LINE__);
- if (loc_eng_dmn_conn_glue_msgsnd(loc_api_resp_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) {
- LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__);
- return -1;
- }
- break;
- }
- default: {
- LOC_LOGD("%s:%d] invalid sender ID!", __func__, __LINE__);
- }
- }
- return 0;
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.h b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
deleted file mode 100644
index 1d8c142..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_ENG_DATA_SERVER_H
-#define LOC_ENG_DATA_SERVER_H
-
-#include "loc_eng_dmn_conn_thread_helper.h"
-
-#ifdef _ANDROID_
-
-#define GPSONE_LOC_API_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_q"
-#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_resp_q"
-#define QUIPC_CTRL_Q_PATH "/data/misc/location/gpsone_d/quipc_ctrl_q"
-#define MSAPM_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapm_ctrl_q"
-#define MSAPU_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapu_ctrl_q"
-
-#else
-
-#define GPSONE_LOC_API_Q_PATH "/tmp/gpsone_loc_api_q"
-#define GPSONE_LOC_API_RESP_Q_PATH "/tmp/gpsone_loc_api_resp_q"
-#define QUIPC_CTRL_Q_PATH "/tmp/quipc_ctrl_q"
-#define MSAPM_CTRL_Q_PATH "/tmp/msapm_ctrl_q"
-#define MSAPU_CTRL_Q_PATH "/tmp/msapu_ctrl_q"
-
-#endif
-
-int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb,
- const char * loc_api_q_path, const char * ctrl_q_path, void *agps_handle);
-int loc_eng_dmn_conn_loc_api_server_unblock(void);
-int loc_eng_dmn_conn_loc_api_server_join(void);
-int loc_eng_dmn_conn_loc_api_server_data_conn(int, int);
-
-#endif /* LOC_ENG_DATA_SERVER_H */
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c
deleted file mode 100644
index e947fa1..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c
+++ /dev/null
@@ -1,222 +0,0 @@
-/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include <linux/stat.h>
-#include <fcntl.h>
-
-#include <linux/types.h>
-
-#include <platform_lib_includes.h>
-#include "loc_eng_dmn_conn_glue_msg.h"
-#include "loc_eng_dmn_conn_handler.h"
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgget
-
-DESCRIPTION
- This function get a message queue
-
- q_path - name path of the message queue
- mode -
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- message queue id
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode)
-{
- int msgqid;
- msgqid = loc_eng_dmn_conn_glue_pipeget(q_path, mode);
- return msgqid;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgremove
-
-DESCRIPTION
- remove a message queue
-
- q_path - name path of the message queue
- msgqid - message queue id
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid)
-{
- int result;
- result = loc_eng_dmn_conn_glue_piperemove(q_path, msgqid);
- return result;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgsnd
-
-DESCRIPTION
- Send a message
-
- msgqid - message queue id
- msgp - pointer to the message to be sent
- msgsz - size of the message
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- number of bytes sent out or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz)
-{
- int result;
- struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp;
- pmsg->msgsz = msgsz;
-
- result = loc_eng_dmn_conn_glue_pipewrite(msgqid, msgp, msgsz);
- if (result != (int) msgsz) {
- LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) msgsz);
- return -1;
- }
-
- return result;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgrcv
-
-DESCRIPTION
- receive a message
-
- msgqid - message queue id
- msgp - pointer to the buffer to hold the message
- msgsz - size of the buffer
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- number of bytes received or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgbufsz)
-{
- int result;
- struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp;
-
- result = loc_eng_dmn_conn_glue_piperead(msgqid, &(pmsg->msgsz), sizeof(pmsg->msgsz));
- if (result != sizeof(pmsg->msgsz)) {
- LOC_LOGE("%s:%d] pipe broken %d\n", __func__, __LINE__, result);
- return -1;
- }
-
- if (msgbufsz < pmsg->msgsz) {
- LOC_LOGE("%s:%d] msgbuf is too small %d < %d\n", __func__, __LINE__, (int) msgbufsz, (int) pmsg->msgsz);
- return -1;
- }
-
- result = loc_eng_dmn_conn_glue_piperead(msgqid, (uint8_t *) msgp + sizeof(pmsg->msgsz), pmsg->msgsz - sizeof(pmsg->msgsz));
- if (result != (int) (pmsg->msgsz - sizeof(pmsg->msgsz))) {
- LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) pmsg->msgsz);
- return -1;
- }
-
- return pmsg->msgsz;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgunblock
-
-DESCRIPTION
- unblock a message queue
-
- msgqid - message queue id
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgunblock(int msgqid)
-{
- return loc_eng_dmn_conn_glue_pipeunblock(msgqid);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_msgflush
-
-DESCRIPTION
- flush out the message in a queue
-
- msgqid - message queue id
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- number of bytes that are flushed out.
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_msgflush(int msgqid)
-{
- int length;
- char buf[128];
-
- do {
- length = loc_eng_dmn_conn_glue_piperead(msgqid, buf, 128);
- LOC_LOGD("%s:%d] %s\n", __func__, __LINE__, buf);
- } while(length);
- return length;
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h
deleted file mode 100644
index d685c87..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_ENG_DMN_CONN_GLUE_MSG_H
-#define LOC_ENG_DMN_CONN_GLUE_MSG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-
-#include <linux/types.h>
-#include "loc_eng_dmn_conn_glue_pipe.h"
-
-int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode);
-int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid);
-int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz);
-int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgsz);
-int loc_eng_dmn_conn_glue_msgflush(int msgqid);
-int loc_eng_dmn_conn_glue_msgunblock(int msgqid);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* LOC_ENG_DMN_CONN_GLUE_MSG_H */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c
deleted file mode 100644
index cbc4ea6..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c
+++ /dev/null
@@ -1,215 +0,0 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
-
-// #include <linux/stat.h>
-#include <fcntl.h>
-// #include <linux/types.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#include "loc_eng_dmn_conn_glue_pipe.h"
-#include <platform_lib_includes.h>
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_pipeget
-
-DESCRIPTION
- create a named pipe.
-
- pipe_name - pipe name path
- mode - mode
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode)
-{
- int fd;
- int result;
-
- LOC_LOGD("%s, mode = %d\n", pipe_name, mode);
- result = mkfifo(pipe_name, 0660);
-
- if ((result == -1) && (errno != EEXIST)) {
- LOC_LOGE("failed: %s\n", strerror(errno));
- return result;
- }
-
- // The mode in mkfifo is not honoured and does not provide the
- // group permissions. Doing chmod to add group permissions.
- result = chmod (pipe_name, 0660);
- if (result != 0){
- LOC_LOGE ("%s failed to change mode for %s, error = %s\n", __func__,
- pipe_name, strerror(errno));
- }
-
- fd = open(pipe_name, mode);
- if (fd <= 0)
- {
- LOC_LOGE("failed: %s\n", strerror(errno));
- }
- LOC_LOGD("fd = %d, %s\n", fd, pipe_name);
- return fd;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_piperemove
-
-DESCRIPTION
- remove a pipe
-
- pipe_name - pipe name path
- fd - fd for the pipe
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd)
-{
- close(fd);
- if (pipe_name != NULL) {
- unlink(pipe_name);
- LOC_LOGD("fd = %d, %s\n", fd, pipe_name);
- }
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_pipewrite
-
-DESCRIPTION
- write to a pipe
-
- fd - fd of a pipe
- buf - buffer for the data to write
- sz - size of the data in buffer
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- number of bytes written or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz)
-{
- int result;
-
- result = write(fd, buf, sz);
-
- /* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */
-
- /* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, result = %d\n", fd, (long) buf, (int) sz, (int) result); */
- return result;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_piperead
-
-DESCRIPTION
- read from a pipe
-
- fd - fd for the pipe
- buf - buffer to hold the data read from pipe
- sz - size of the buffer
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- number of bytes read from pipe or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz)
-{
- int len;
-
- len = read(fd, buf, sz);
-
- /* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */
-
- /* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, len = %d\n", fd, (long) buf, (int) sz, len); */
- return len;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_glue_pipeunblock
-
-DESCRIPTION
- unblock a pipe
-
- fd - fd for the pipe
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0 for success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_glue_pipeunblock(int fd)
-{
- int result;
- struct flock flock_v;
- LOC_LOGD("\n");
-// result = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NDELAY);
- flock_v.l_type = F_UNLCK;
- flock_v.l_len = 32;
- result = fcntl(fd, F_SETLK, &flock_v);
- if (result < 0) {
- LOC_LOGE("fcntl failure, %s\n", strerror(errno));
- }
-
- return result;
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h
deleted file mode 100644
index b2fa3a0..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_ENG_DMN_CONN_GLUE_PIPE_H
-#define LOC_ENG_DMN_CONN_GLUE_PIPE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include <linux/types.h>
-
-int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode);
-int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd);
-int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz);
-int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz);
-
-int loc_eng_dmn_conn_glue_pipeflush(int fd);
-int loc_eng_dmn_conn_glue_pipeunblock(int fd);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* LOC_ENG_DMN_CONN_GLUE_PIPE_H */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp
deleted file mode 100644
index 7fbe62f..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp
+++ /dev/null
@@ -1,236 +0,0 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <platform_lib_includes.h>
-#include "loc_eng_msg.h"
-#include "loc_eng_dmn_conn.h"
-#include "loc_eng_dmn_conn_handler.h"
-
-void* loc_api_handle = NULL;
-
-int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len)
-{
- LOC_LOGD("%s:%d]\n", __func__, __LINE__);
-#ifndef DEBUG_DMN_LOC_API
- if (NULL == loc_api_handle) {
- LOC_LOGE("%s:%d] NO agps data handle\n", __func__, __LINE__);
- return 1;
- }
-
- if (NULL != loc_api_handle) {
- AGpsExtType type;
- switch (pmsg->cmsg.cmsg_if_request.type) {
- case IF_REQUEST_TYPE_SUPL:
- {
- LOC_LOGD("IF_REQUEST_TYPE_SUPL");
- type = LOC_AGPS_TYPE_SUPL;
- break;
- }
- case IF_REQUEST_TYPE_WIFI:
- {
- LOC_LOGD("IF_REQUEST_TYPE_WIFI");
- type = LOC_AGPS_TYPE_WIFI;
- break;
- }
- case IF_REQUEST_TYPE_ANY:
- {
- LOC_LOGD("IF_REQUEST_TYPE_ANY");
- type = LOC_AGPS_TYPE_ANY;
- break;
- }
- default:
- {
- LOC_LOGD("invalid IF_REQUEST_TYPE!");
- return -1;
- }
- }
- switch (pmsg->cmsg.cmsg_if_request.sender_id) {
- case IF_REQUEST_SENDER_ID_QUIPC:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- true);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_MSAPM:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- true);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_MSAPU:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- true);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_GPSONE_DAEMON:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON");
- LocEngReqRelBIT* msg =
- new LocEngReqRelBIT(loc_api_handle,
- type,
- pmsg->cmsg.cmsg_if_request.ipv4_addr,
- (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr,
- true);
- msg->send();
- break;
- }
- default:
- {
- LOC_LOGD("invalid IF_REQUEST_SENDER_ID!");
- return -1;
- }
- }
- }
-
-#else
- loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, GPSONE_LOC_API_IF_REQUEST_SUCCESS);
-#endif
- return 0;
-}
-
-int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len)
-{
- LOC_LOGD("%s:%d]\n", __func__, __LINE__);
-#ifndef DEBUG_DMN_LOC_API
- AGpsExtType type;
- switch (pmsg->cmsg.cmsg_if_request.type) {
- case IF_REQUEST_TYPE_SUPL:
- {
- LOC_LOGD("IF_REQUEST_TYPE_SUPL");
- type = LOC_AGPS_TYPE_SUPL;
- break;
- }
- case IF_REQUEST_TYPE_WIFI:
- {
- LOC_LOGD("IF_REQUEST_TYPE_WIFI");
- type = LOC_AGPS_TYPE_WIFI;
- break;
- }
- case IF_REQUEST_TYPE_ANY:
- {
- LOC_LOGD("IF_REQUEST_TYPE_ANY");
- type = LOC_AGPS_TYPE_ANY;
- break;
- }
- default:
- {
- LOC_LOGD("invalid IF_REQUEST_TYPE!");
- return -1;
- }
- }
- switch (pmsg->cmsg.cmsg_if_request.sender_id) {
- case IF_REQUEST_SENDER_ID_QUIPC:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- false);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_MSAPM:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- false);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_MSAPU:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU");
- LocEngReqRelWifi* msg =
- new LocEngReqRelWifi(loc_api_handle,
- type,
- LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU,
- (char*)pmsg->cmsg.cmsg_if_request.ssid,
- (char*)pmsg->cmsg.cmsg_if_request.password,
- false);
- msg->send();
- break;
- }
- case IF_REQUEST_SENDER_ID_GPSONE_DAEMON:
- {
- LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON");
- LocEngReqRelBIT* msg =
- new LocEngReqRelBIT(loc_api_handle,
- type,
- pmsg->cmsg.cmsg_if_request.ipv4_addr,
- (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr,
- false);
- msg->send();
- break;
- }
- default:
- {
- LOC_LOGD("invalid IF_REQUEST_SENDER_ID!");
- return -1;
- }
- }
-#else
- loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, GPSONE_LOC_API_IF_RELEASE_SUCCESS);
-#endif
- return 0;
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h
deleted file mode 100644
index f1a51c7..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* Copyright (c) 2011-2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_ENG_DATA_SERVER_HANDLER
-#define LOC_ENG_DATA_SERVER_HANDLER
-
-#include <linux/types.h>
-#include <arpa/inet.h>
-
-//for SSID_BUF_SIZE
-#ifndef SSID_BUF_SIZE
- #define SSID_BUF_SIZE (32+1)
-#endif
-
-enum {
- /* 0x0 - 0xEF is reserved for daemon internal */
- GPSONE_LOC_API_IF_REQUEST = 0xF0,
- GPSONE_LOC_API_IF_RELEASE,
- GPSONE_LOC_API_RESPONSE,
- GPSONE_UNBLOCK,
-};
-
-enum {
- GPSONE_LOC_API_IF_REQUEST_SUCCESS = 0xF0,
- GPSONE_LOC_API_IF_RELEASE_SUCCESS,
- GPSONE_LOC_API_IF_FAILURE,
-};
-
-
-struct ctrl_msg_response {
- int result;
-};
-
-struct ctrl_msg_unblock {
- int reserved;
-};
-
-typedef enum {
- IF_REQUEST_TYPE_SUPL = 0,
- IF_REQUEST_TYPE_WIFI,
- IF_REQUEST_TYPE_ANY
-} ctrl_if_req_type_e_type;
-
-typedef enum {
- IF_REQUEST_SENDER_ID_QUIPC = 0,
- IF_REQUEST_SENDER_ID_MSAPM,
- IF_REQUEST_SENDER_ID_MSAPU,
- IF_REQUEST_SENDER_ID_GPSONE_DAEMON,
- IF_REQUEST_SENDER_ID_MODEM
-} ctrl_if_req_sender_id_e_type;
-
-struct ctrl_msg_if_request {
- ctrl_if_req_type_e_type type;
- ctrl_if_req_sender_id_e_type sender_id;
- unsigned long ipv4_addr;
- unsigned char ipv6_addr[16];
- char ssid[SSID_BUF_SIZE];
- char password[SSID_BUF_SIZE];
-};
-
-/* do not change this structure */
-struct ctrl_msgbuf {
- size_t msgsz;
- uint16_t reserved1;
- uint32_t reserved2;
- uint8_t ctrl_type;
- union {
- struct ctrl_msg_response cmsg_response;
- struct ctrl_msg_unblock cmsg_unblock;
- struct ctrl_msg_if_request cmsg_if_request;
- } cmsg;
-};
-
-extern void* loc_api_handle;
-
-int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len);
-int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len);
-
-#endif /* LOC_ENG_DATA_SERVER_HANDLER */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c
deleted file mode 100644
index b30f6d7..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c
+++ /dev/null
@@ -1,398 +0,0 @@
-/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#include <stdio.h>
-
-#include <platform_lib_includes.h>
-#include "loc_eng_dmn_conn_thread_helper.h"
-
-/*===========================================================================
-FUNCTION thelper_signal_init
-
-DESCRIPTION
- This function will initialize the conditional variable resources.
-
- thelper - thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result;
- thelper->thread_exit = 0;
- thelper->thread_ready = 0;
- result = pthread_cond_init( &thelper->thread_cond, NULL);
- if (result) {
- return result;
- }
-
- result = pthread_mutex_init(&thelper->thread_mutex, NULL);
- if (result) {
- pthread_cond_destroy(&thelper->thread_cond);
- }
- return result;
-}
-
-/*===========================================================================
-FUNCTION
-
-DESCRIPTION
- This function will destroy the conditional variable resources
-
- thelper - pointer to thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result, ret_result = 0;
- result = pthread_cond_destroy( &thelper->thread_cond);
- if (result) {
- ret_result = result;
- }
-
- result = pthread_mutex_destroy(&thelper->thread_mutex);
- if (result) {
- ret_result = result;
- }
-
- return ret_result;
-}
-
-/*===========================================================================
-FUNCTION thelper_signal_wait
-
-DESCRIPTION
- This function will be blocked on the conditional variable until thelper_signal_ready
- is called
-
- thelper - pointer to thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result = 0;
-
- pthread_mutex_lock(&thelper->thread_mutex);
- if (!thelper->thread_ready && !thelper->thread_exit) {
- result = pthread_cond_wait(&thelper->thread_cond, &thelper->thread_mutex);
- }
-
- if (thelper->thread_exit) {
- result = -1;
- }
- pthread_mutex_unlock(&thelper->thread_mutex);
-
- return result;
-}
-
-/*===========================================================================
-FUNCTION thelper_signal_ready
-
-DESCRIPTION
- This function will wake up the conditional variable
-
- thelper - pointer to thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result;
-
- LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
-
- pthread_mutex_lock(&thelper->thread_mutex);
- thelper->thread_ready = 1;
- result = pthread_cond_signal(&thelper->thread_cond);
- pthread_mutex_unlock(&thelper->thread_mutex);
-
- return result;
-}
-
-/*===========================================================================
-FUNCTION thelper_signal_block
-
-DESCRIPTION
- This function will set the thread ready to 0 to block the thelper_signal_wait
-
- thelper - pointer to thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- if thread_ready is set
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result = thelper->thread_ready;
-
- LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
-
- pthread_mutex_lock(&thelper->thread_mutex);
- thelper->thread_ready = 0;
- pthread_mutex_unlock(&thelper->thread_mutex);
-
- return result;
-}
-
-/*===========================================================================
-FUNCTION thelper_main
-
-DESCRIPTION
- This function is the main thread. It will be launched as a child thread
-
- data - pointer to the instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- NULL
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static void * thelper_main(void *data)
-{
- int result = 0;
- struct loc_eng_dmn_conn_thelper * thelper = (struct loc_eng_dmn_conn_thelper *) data;
-
- if (thelper->thread_proc_init) {
- result = thelper->thread_proc_init(thelper->thread_context);
- if (result < 0) {
- thelper->thread_exit = 1;
- thelper_signal_ready(thelper);
- LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
- return NULL;
- }
- }
-
- thelper_signal_ready(thelper);
-
- if (thelper->thread_proc_pre) {
- result = thelper->thread_proc_pre(thelper->thread_context);
- if (result < 0) {
- thelper->thread_exit = 1;
- LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
- return NULL;
- }
- }
-
- do {
- if (thelper->thread_proc) {
- result = thelper->thread_proc(thelper->thread_context);
- if (result < 0) {
- thelper->thread_exit = 1;
- LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
- }
- }
- } while (thelper->thread_exit == 0);
-
- if (thelper->thread_proc_post) {
- result = thelper->thread_proc_post(thelper->thread_context);
- }
-
- if (result != 0) {
- LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper);
- }
- return NULL;
-}
-
-static void thelper_main_2(void *data)
-{
- thelper_main(data);
- return;
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_launch_thelper
-
-DESCRIPTION
- This function will initialize the thread context and launch the thelper_main
-
- thelper - pointer to thelper instance
- thread_proc_init - The initialization function pointer
- thread_proc_pre - The function to call before task loop and after initialization
- thread_proc - The task loop
- thread_proc_post - The function to call after the task loop
- context - the context for the above four functions
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper,
- int (*thread_proc_init) (void * context),
- int (*thread_proc_pre) (void * context),
- int (*thread_proc) (void * context),
- int (*thread_proc_post) (void * context),
- thelper_create_thread create_thread_cb,
- void * context)
-{
- int result;
-
- thelper_signal_init(thelper);
-
- if (context) {
- thelper->thread_context = context;
- }
-
- thelper->thread_proc_init = thread_proc_init;
- thelper->thread_proc_pre = thread_proc_pre;
- thelper->thread_proc = thread_proc;
- thelper->thread_proc_post = thread_proc_post;
-
- LOC_LOGD("%s:%d] 0x%lx call pthread_create\n", __func__, __LINE__, (long) thelper);
- if (create_thread_cb) {
- result = 0;
- thelper->thread_id = create_thread_cb("loc_eng_dmn_conn",
- thelper_main_2, (void *)thelper);
- } else {
- result = pthread_create(&thelper->thread_id, NULL,
- thelper_main, (void *)thelper);
- }
-
- if (result != 0) {
- LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
- return -1;
- }
-
- LOC_LOGD("%s:%d] 0x%lx pthread_create done\n", __func__, __LINE__, (long) thelper);
-
- thelper_signal_wait(thelper);
-
- LOC_LOGD("%s:%d] 0x%lx pthread ready\n", __func__, __LINE__, (long) thelper);
- return thelper->thread_exit;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_unblock_thelper
-
-DESCRIPTION
- This function unblocks thelper_main to release the thread
-
- thelper - pointer to thelper instance
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper)
-{
- LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
- thelper->thread_exit = 1;
- return 0;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_dmn_conn_join_thelper
-
- thelper - pointer to thelper instance
-
-DESCRIPTION
- This function will wait for the thread of thelper_main to finish
-
-DEPENDENCIES
- None
-
-RETURN VALUE
- 0: success or negative value for failure
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper)
-{
- int result;
-
- LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
- result = pthread_join(thelper->thread_id, NULL);
- if (result != 0) {
- LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
- }
- LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper);
-
- thelper_signal_destroy(thelper);
-
- return result;
-}
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h b/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h
deleted file mode 100644
index 89e598b..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright (c) 2011, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef __LOC_ENG_DMN_CONN_THREAD_HELPER_H__
-#define __LOC_ENG_DMN_CONN_THREAD_HELPER_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#include <pthread.h>
-
-struct loc_eng_dmn_conn_thelper {
- unsigned char thread_exit;
- unsigned char thread_ready;
- pthread_cond_t thread_cond;
- pthread_mutex_t thread_mutex;
- pthread_t thread_id;
- void * thread_context;
- int (*thread_proc_init) (void * context);
- int (*thread_proc_pre) (void * context);
- int (*thread_proc) (void * context);
- int (*thread_proc_post) (void * context);
-};
-
-typedef pthread_t (* thelper_create_thread)(const char* name, void (*start)(void *), void* arg);
-int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper,
- int (*thread_proc_init) (void * context),
- int (*thread_proc_pre) (void * context),
- int (*thread_proc) (void * context),
- int (*thread_proc_post) (void * context),
- thelper_create_thread create_thread_cb,
- void * context);
-
-int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper);
-int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper);
-
-/* if only need to use signal */
-int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper);
-int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper);
-int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper);
-int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper);
-int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_log.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_log.cpp
deleted file mode 100644
index 3a34167..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_log.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng"
-
-#include "loc_log.h"
-#include "loc_eng_log.h"
-
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_msg.h b/msm8998/loc_api/libloc_api_50001/loc_eng_msg.h
deleted file mode 100644
index 6f335e6..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_msg.h
+++ /dev/null
@@ -1,305 +0,0 @@
-/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-#ifndef LOC_ENG_MSG_H
-#define LOC_ENG_MSG_H
-
-
-#include <gps_extended.h>
-#include <stdlib.h>
-#include <string.h>
-#include <loc_eng_log.h>
-#include <loc_eng.h>
-#include <MsgTask.h>
-#include <LocEngAdapter.h>
-#include <platform_lib_includes.h>
-
-#ifndef SSID_BUF_SIZE
- #define SSID_BUF_SIZE (32+1)
-#endif
-#if defined(USE_GLIB) && !defined(OFF_TARGET)
-
-#include <glib.h>
-
-#endif /* USE_GLIB */
-#include "platform_lib_includes.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-using namespace loc_core;
-
-struct LocEngPositionMode : public LocMsg {
- LocEngAdapter* mAdapter;
- const LocPosMode mPosMode;
- LocEngPositionMode(LocEngAdapter* adapter, LocPosMode &mode);
- virtual void proc() const;
- virtual void log() const;
- void send() const;
-};
-
-
-struct LocEngStartFix : public LocMsg {
- LocEngAdapter* mAdapter;
- LocEngStartFix(LocEngAdapter* adapter);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngStopFix : public LocMsg {
- LocEngAdapter* mAdapter;
- LocEngStopFix(LocEngAdapter* adapter);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngReportPosition : public LocMsg {
- LocAdapterBase* mAdapter;
- const UlpLocation mLocation;
- const GpsLocationExtended mLocationExtended;
- const void* mLocationExt;
- const enum loc_sess_status mStatus;
- const LocPosTechMask mTechMask;
- LocEngReportPosition(LocAdapterBase* adapter,
- UlpLocation &loc,
- GpsLocationExtended &locExtended,
- void* locExt,
- enum loc_sess_status st,
- LocPosTechMask technology);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngReportSv : public LocMsg {
- LocAdapterBase* mAdapter;
- const LocGnssSvStatus mSvStatus;
- const GpsLocationExtended mLocationExtended;
- const void* mSvExt;
- LocEngReportSv(LocAdapterBase* adapter,
- LocGnssSvStatus &sv,
- GpsLocationExtended &locExtended,
- void* svExtended);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngReportStatus : public LocMsg {
- LocAdapterBase* mAdapter;
- const LocGpsStatusValue mStatus;
- LocEngReportStatus(LocAdapterBase* adapter,
- LocGpsStatusValue engineStatus);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngReportNmea : public LocMsg {
- void* mLocEng;
- char* const mNmea;
- const int mLen;
- LocEngReportNmea(void* locEng,
- const char* data, int len);
- inline virtual ~LocEngReportNmea()
- {
- delete[] mNmea;
- }
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngReportXtraServer : public LocMsg {
- void* mLocEng;
- int mMaxLen;
- char *mServers;
- LocEngReportXtraServer(void* locEng,
- const char *url1, const char *url2,
- const char *url3, const int maxlength);
- inline virtual ~LocEngReportXtraServer()
- {
- delete[] mServers;
- }
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngSuplEsOpened : public LocMsg {
- void* mLocEng;
- LocEngSuplEsOpened(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngSuplEsClosed : public LocMsg {
- void* mLocEng;
- LocEngSuplEsClosed(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngRequestSuplEs : public LocMsg {
- void* mLocEng;
- const int mID;
- LocEngRequestSuplEs(void* locEng, int id);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngRequestATL : public LocMsg {
- void* mLocEng;
- const int mID;
- const AGpsExtType mType;
- LocEngRequestATL(void* locEng, int id,
- AGpsExtType agps_type);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngReleaseATL : public LocMsg {
- void* mLocEng;
- const int mID;
- LocEngReleaseATL(void* locEng, int id);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngReqRelBIT : public LocMsg {
- void* mLocEng;
- const AGpsExtType mType;
- const int mIPv4Addr;
- char* const mIPv6Addr;
- const bool mIsReq;
- LocEngReqRelBIT(void* instance, AGpsExtType type,
- int ipv4, char* ipv6, bool isReq);
- virtual ~LocEngReqRelBIT();
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngReqRelWifi : public LocMsg {
- void* mLocEng;
- const AGpsExtType mType;
- const loc_if_req_sender_id_e_type mSenderId;
- char* const mSSID;
- char* const mPassword;
- const bool mIsReq;
- LocEngReqRelWifi(void* locEng, AGpsExtType type,
- loc_if_req_sender_id_e_type sender_id,
- char* s, char* p, bool isReq);
- virtual ~LocEngReqRelWifi();
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngRequestXtra : public LocMsg {
- void* mLocEng;
- LocEngRequestXtra(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngRequestTime : public LocMsg {
- void* mLocEng;
- LocEngRequestTime(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngRequestNi : public LocMsg {
- void* mLocEng;
- const LocGpsNiNotification mNotify;
- const void *mPayload;
- LocEngRequestNi(void* locEng,
- LocGpsNiNotification ¬if,
- const void* data);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngDown : public LocMsg {
- void* mLocEng;
- LocEngDown(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngUp : public LocMsg {
- void* mLocEng;
- LocEngUp(void* locEng);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-struct LocEngGetZpp : public LocMsg {
- LocEngAdapter* mAdapter;
- LocEngGetZpp(LocEngAdapter* adapter);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
- void send() const;
-};
-
-struct LocEngReportGnssMeasurement : public LocMsg {
- void* mLocEng;
- const LocGnssData mGnssData;
- LocEngReportGnssMeasurement(void* locEng,
- LocGnssData &gnssData);
- virtual void proc() const;
- void locallog() const;
- virtual void log() const;
-};
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* LOC_ENG_MSG_H */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_ni.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_ni.cpp
deleted file mode 100644
index 3a7d8fb..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_ni.cpp
+++ /dev/null
@@ -1,413 +0,0 @@
-/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-#include <pthread.h>
-#include <errno.h>
-#include <string.h>
-#include <ctype.h>
-#include <unistd.h>
-#include <time.h>
-#include <MsgTask.h>
-
-#include <loc_eng.h>
-
-#include <platform_lib_includes.h>
-
-using namespace loc_core;
-
-/*=============================================================================
- *
- * DATA DECLARATION
- *
- *============================================================================*/
-
-/*=============================================================================
- *
- * FUNCTION DECLARATIONS
- *
- *============================================================================*/
-static void* ni_thread_proc(void *args);
-
-struct LocEngInformNiResponse : public LocMsg {
- LocEngAdapter* mAdapter;
- const LocGpsUserResponseType mResponse;
- const void *mPayload;
- inline LocEngInformNiResponse(LocEngAdapter* adapter,
- LocGpsUserResponseType resp,
- const void* data) :
- LocMsg(), mAdapter(adapter),
- mResponse(resp), mPayload(data)
- {
- locallog();
- }
- inline ~LocEngInformNiResponse()
- {
- // this is a bit weird since mPayload is not
- // allocated by this class. But there is no better way.
- // mPayload actually won't be NULL here.
- free((void*)mPayload);
- }
- inline virtual void proc() const
- {
- mAdapter->informNiResponse(mResponse, mPayload);
- }
- inline void locallog() const
- {
- LOC_LOGV("LocEngInformNiResponse - "
- "response: %s\n mPayload: %p",
- loc_get_ni_response_name(mResponse),
- mPayload);
- }
- inline virtual void log() const
- {
- locallog();
- }
-};
-
-/*===========================================================================
-
-FUNCTION loc_eng_ni_request_handler
-
-DESCRIPTION
- Displays the NI request and awaits user input. If a previous request is
- in session, it is ignored.
-
-RETURN VALUE
- none
-
-===========================================================================*/
-void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data,
- const LocGpsNiNotification *notif,
- const void* passThrough)
-{
- ENTRY_LOG();
- char lcs_addr[32]; // Decoded LCS address for UMTS CP NI
- loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
- loc_eng_ni_session_s_type* pSession = NULL;
-
- if (NULL == loc_eng_data.ni_notify_cb) {
- EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
- return;
- }
-
- if (notif->ni_type == LOC_GPS_NI_TYPE_EMERGENCY_SUPL) {
- if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
- LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d",
- notif->ni_type);
- if (NULL != passThrough) {
- free((void*)passThrough);
- }
- } else {
- pSession = &loc_eng_ni_data_p->sessionEs;
- }
- } else {
- if (NULL != loc_eng_ni_data_p->session.rawRequest ||
- NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
- LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d",
- notif->ni_type);
- if (NULL != passThrough) {
- free((void*)passThrough);
- }
- } else {
- pSession = &loc_eng_ni_data_p->session;
- }
- }
-
-
- if (pSession) {
- /* Save request */
- pSession->rawRequest = (void*)passThrough;
- pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter;
- pSession->adapter = loc_eng_data.adapter;
-
- /* Fill in notification */
- ((LocGpsNiNotification*)notif)->notification_id = pSession->reqID;
-
- if (notif->notify_flags == LOC_GPS_NI_PRIVACY_OVERRIDE)
- {
- loc_eng_mute_one_session(loc_eng_data);
- }
-
- /* Log requestor ID and text for debugging */
- LOC_LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif->ni_type, notif->timeout, notif->default_response);
- LOC_LOGI(" requestor_id: %s (encoding: %d)", notif->requestor_id, notif->requestor_id_encoding);
- LOC_LOGI(" text: %s text (encoding: %d)", notif->text, notif->text_encoding);
- if (notif->extras[0])
- {
- LOC_LOGI(" extras: %s", notif->extras);
- }
-
- /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though
- * the OEM layer in java does not do so.
- **/
- pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME);
- LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft);
-
- int rc = 0;
- rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession);
- if (rc)
- {
- LOC_LOGE("Loc NI thread is not created.\n");
- }
- rc = pthread_detach(pSession->thread);
- if (rc)
- {
- LOC_LOGE("Loc NI thread is not detached.\n");
- }
-
- CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id);
- loc_eng_data.ni_notify_cb((LocGpsNiNotification*)notif, gps_conf.SUPL_ES != 0);
- }
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-
-FUNCTION ni_thread_proc
-
-===========================================================================*/
-static void* ni_thread_proc(void *args)
-{
- ENTRY_LOG();
-
- loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args;
- int rc = 0; /* return code from pthread calls */
-
- struct timeval present_time;
- struct timespec expire_time;
-
- LOC_LOGD("Starting Loc NI thread...\n");
- pthread_mutex_lock(&pSession->tLock);
- /* Calculate absolute expire time */
- gettimeofday(&present_time, NULL);
- expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft;
- expire_time.tv_nsec = present_time.tv_usec * 1000;
- LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n",
- (long) expire_time.tv_sec, pSession->respTimeLeft );
-
- while (!pSession->respRecvd)
- {
- rc = pthread_cond_timedwait(&pSession->tCond,
- &pSession->tLock,
- &expire_time);
- if (rc == ETIMEDOUT)
- {
- pSession->resp = LOC_GPS_NI_RESPONSE_NORESP;
- LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc );
- break;
- }
- }
- LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from "
- "pthread_cond_timedwait = %d\n",rc );
- pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/
-
- LOC_LOGD("pSession->resp is %d\n",pSession->resp);
-
- // adding this check to support modem restart, in which case, we need the thread
- // to exit without calling sending data. We made sure that rawRequest is NULL in
- // loc_eng_ni_reset_on_engine_restart()
- LocEngAdapter* adapter = pSession->adapter;
- LocEngInformNiResponse *msg = NULL;
-
- if (NULL != pSession->rawRequest) {
- if (pSession->resp != LOC_GPS_NI_RESPONSE_IGNORE) {
- LOC_LOGD("pSession->resp != LOC_GPS_NI_RESPONSE_IGNORE \n");
- msg = new LocEngInformNiResponse(adapter,
- pSession->resp,
- pSession->rawRequest);
- } else {
- LOC_LOGD("this is the ignore reply for SUPL ES\n");
- free(pSession->rawRequest);
- }
- pSession->rawRequest = NULL;
- }
- pthread_mutex_unlock(&pSession->tLock);
-
- pSession->respTimeLeft = 0;
- pSession->reqID = 0;
-
- if (NULL != msg) {
- LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n");
- adapter->sendMsg(msg);
- }
-
- EXIT_LOG(%s, VOID_RET);
- return NULL;
-}
-
-void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
-
- if (NULL == loc_eng_data.ni_notify_cb) {
- EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
- return;
- }
-
- // only if modem has requested but then died.
- if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
- free(loc_eng_ni_data_p->sessionEs.rawRequest);
- loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
-
- pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock);
- // the goal is to wake up ni_thread_proc
- // and let it exit.
- loc_eng_ni_data_p->sessionEs.respRecvd = TRUE;
- pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond);
- pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock);
- }
-
- if (NULL != loc_eng_ni_data_p->session.rawRequest) {
- free(loc_eng_ni_data_p->session.rawRequest);
- loc_eng_ni_data_p->session.rawRequest = NULL;
-
- pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
- // the goal is to wake up ni_thread_proc
- // and let it exit.
- loc_eng_ni_data_p->session.respRecvd = TRUE;
- pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
- pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_ni_init
-
-DESCRIPTION
- This function initializes the NI interface
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callbacks)
-{
- ENTRY_LOG_CALLFLOW();
-
- if(callbacks == NULL)
- EXIT_LOG(%s, "loc_eng_ni_init: failed, cb is NULL");
- else if (NULL == callbacks->notify_cb) {
- EXIT_LOG(%s, "loc_eng_ni_init: failed, no cb.");
- } else if (NULL != loc_eng_data.ni_notify_cb) {
- EXIT_LOG(%s, "loc_eng_ni_init: already inited.");
- } else {
- loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
- loc_eng_ni_data_p->sessionEs.respTimeLeft = 0;
- loc_eng_ni_data_p->sessionEs.respRecvd = FALSE;
- loc_eng_ni_data_p->sessionEs.rawRequest = NULL;
- loc_eng_ni_data_p->sessionEs.reqID = 0;
- pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL);
- pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL);
-
- loc_eng_ni_data_p->session.respTimeLeft = 0;
- loc_eng_ni_data_p->session.respRecvd = FALSE;
- loc_eng_ni_data_p->session.rawRequest = NULL;
- loc_eng_ni_data_p->session.reqID = 0;
- pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL);
- pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL);
-
- loc_eng_data.ni_notify_cb = callbacks->notify_cb;
- EXIT_LOG(%s, VOID_RET);
- }
-}
-
-/*===========================================================================
-FUNCTION loc_eng_ni_respond
-
-DESCRIPTION
- This function receives user response from upper layer framework
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- None
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data,
- int notif_id, LocGpsUserResponseType user_response)
-{
- ENTRY_LOG_CALLFLOW();
- loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data;
- loc_eng_ni_session_s_type* pSession = NULL;
-
- if (NULL == loc_eng_data.ni_notify_cb) {
- EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet.");
- return;
- }
-
- if (notif_id == loc_eng_ni_data_p->sessionEs.reqID &&
- NULL != loc_eng_ni_data_p->sessionEs.rawRequest) {
- pSession = &loc_eng_ni_data_p->sessionEs;
- // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
- if (user_response == LOC_GPS_NI_RESPONSE_ACCEPT &&
- NULL != loc_eng_ni_data_p->session.rawRequest) {
- pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock);
- loc_eng_ni_data_p->session.resp = LOC_GPS_NI_RESPONSE_IGNORE;
- loc_eng_ni_data_p->session.respRecvd = TRUE;
- pthread_cond_signal(&loc_eng_ni_data_p->session.tCond);
- pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock);
- }
- } else if (notif_id == loc_eng_ni_data_p->session.reqID &&
- NULL != loc_eng_ni_data_p->session.rawRequest) {
- pSession = &loc_eng_ni_data_p->session;
- }
-
- if (pSession) {
- LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id);
- pthread_mutex_lock(&pSession->tLock);
- pSession->resp = user_response;
- pSession->respRecvd = TRUE;
- pthread_cond_signal(&pSession->tCond);
- pthread_mutex_unlock(&pSession->tLock);
- }
- else {
- LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id);
- }
-
- EXIT_LOG(%s, VOID_RET);
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_ni.h b/msm8998/loc_api/libloc_api_50001/loc_eng_ni.h
deleted file mode 100644
index afb406f..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_ni.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (c) 2009,2011,2014 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_NI_H
-#define LOC_ENG_NI_H
-
-#include <stdbool.h>
-#include <LocEngAdapter.h>
-
-#define LOC_NI_NO_RESPONSE_TIME 20 /* secs */
-#define LOC_NI_NOTIF_KEY_ADDRESS "Address"
-#define LOC_GPS_NI_RESPONSE_IGNORE 4
-
-typedef struct {
- pthread_t thread; /* NI thread */
- int respTimeLeft; /* examine time for NI response */
- bool respRecvd; /* NI User reponse received or not from Java layer*/
- void* rawRequest;
- int reqID; /* ID to check against response */
- LocGpsUserResponseType resp;
- pthread_cond_t tCond;
- pthread_mutex_t tLock;
- LocEngAdapter* adapter;
-} loc_eng_ni_session_s_type;
-
-typedef struct {
- loc_eng_ni_session_s_type session; /* SUPL NI Session */
- loc_eng_ni_session_s_type sessionEs; /* Emergency SUPL NI Session */
- int reqIDCounter;
-} loc_eng_ni_data_s_type;
-
-
-#endif /* LOC_ENG_NI_H */
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.cpp
deleted file mode 100644
index 951b53c..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.cpp
+++ /dev/null
@@ -1,1039 +0,0 @@
-/* Copyright (c) 2012, 2016, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng_nmea"
-#include <loc_eng.h>
-#include <loc_eng_nmea.h>
-#include <math.h>
-#include <platform_lib_includes.h>
-
-#define GLONASS_SV_ID_OFFSET 64
-#define MAX_SATELLITES_IN_USE 12
-typedef struct loc_nmea_sv_meta_s
-{
- char talker[3];
- LocGnssConstellationType svType;
- uint32_t mask;
- uint32_t svIdOffset;
-} loc_nmea_sv_meta;
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_sv_meta_init
-
-DESCRIPTION
- Init loc_nmea_sv_meta passed in
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- Pointer to loc_nmea_sv_meta
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_eng_data_s_type *loc_eng_data_p,
- loc_nmea_sv_meta& sv_meta, LocGnssConstellationType svType, bool needCombine)
-{
- if (!loc_eng_data_p)
- return NULL;
-
- memset(&sv_meta, 0, sizeof(sv_meta));
- sv_meta.svType = svType;
- sv_meta.talker[0] = 'G';
-
- switch (svType)
- {
- case LOC_GNSS_CONSTELLATION_GPS:
- sv_meta.talker[1] = 'P';
- sv_meta.mask = loc_eng_data_p->gps_used_mask;
- break;
- case LOC_GNSS_CONSTELLATION_GLONASS:
- sv_meta.talker[1] = 'L';
- sv_meta.mask = loc_eng_data_p->glo_used_mask;
- // GLONASS SV ids are from 65-96
- sv_meta.svIdOffset = GLONASS_SV_ID_OFFSET;
- break;
- case LOC_GNSS_CONSTELLATION_GALILEO:
- sv_meta.talker[1] = 'A';
- sv_meta.mask = loc_eng_data_p->gal_used_mask;
- break;
- default:
- LOC_LOGE("NMEA Error unknow constellation type: %d", svType);
- return NULL;
- }
- if (needCombine &&
- (loc_eng_data_p->gps_used_mask ? 1 : 0) +
- (loc_eng_data_p->glo_used_mask ? 1 : 0) +
- (loc_eng_data_p->gal_used_mask ? 1 : 0) > 1)
- {
- // If GPS, GLONASS, Galileo etc. are combined
- // to obtain the reported position solution,
- // talker shall be set to GN, to indicate that
- // the satellites are used in a combined solution
- sv_meta.talker[1] = 'N';
- }
- return &sv_meta;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_count_bits
-
-DESCRIPTION
- Count how many bits are set in mask
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- Bits number set in mask
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-static uint32_t loc_eng_nmea_count_bits(uint32_t mask)
-{
- uint32_t count = 0;
- while (mask)
- {
- if (mask & 1)
- count++;
- mask = mask >> 1;
- }
- return count;
-}
-
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_send
-
-DESCRIPTION
- send out NMEA sentence
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- Total length of the nmea sentence
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p)
-{
- struct timeval tv;
- gettimeofday(&tv, (struct timezone *) NULL);
- int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
- if (loc_eng_data_p->nmea_cb != NULL)
- loc_eng_data_p->nmea_cb(now, pNmea, length);
-
- loc_eng_data_p->adapter->getUlpProxy()->reportNmea(pNmea, length);
-
- LOC_LOGD("NMEA <%s", pNmea);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_put_checksum
-
-DESCRIPTION
- Generate NMEA sentences generated based on position report
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- Total length of the nmea sentence
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_nmea_put_checksum(char *pNmea, int maxSize)
-{
- uint8_t checksum = 0;
- int length = 0;
-
- pNmea++; //skip the $
- while (*pNmea != '\0')
- {
- checksum ^= *pNmea++;
- length++;
- }
-
- // length now contains nmea sentence string length not including $ sign.
- int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum);
-
- // total length of nmea sentence is length of nmea sentence inc $ sign plus
- // length of checksum (+1 is to cover the $ character in the length).
- return (length + checksumLength + 1);
-}
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_generate_GSA
-
-DESCRIPTION
- Generate NMEA GSA sentences generated based on position report
- Currently below sentences are generated:
- - $GPGSA : GPS DOP and active SVs
- - $GLGSA : GLONASS DOP and active SVs
- - $GAGSA : GALILEO DOP and active SVs
- - $GNGSA : GNSS DOP and active SVs
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- Number of SVs used
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-uint32_t loc_eng_nmea_generate_GSA(loc_eng_data_s_type *loc_eng_data_p,
- const GpsLocationExtended &locationExtended,
- char* sentence,
- int bufSize,
- loc_nmea_sv_meta* sv_meta_p)
-{
- if (!loc_eng_data_p || !sentence || bufSize <= 0 || !sv_meta_p)
- {
- LOC_LOGE("NMEA Error invalid arguments.");
- return 0;
- }
-
- char* pMarker = sentence;
- int lengthRemaining = bufSize;
- int length = 0;
-
- uint32_t svUsedCount = 0;
- uint32_t svUsedList[32] = {0};
-
- char fixType = '\0';
-
- const char* talker = sv_meta_p->talker;
- uint32_t svIdOffset = sv_meta_p->svIdOffset;
- uint32_t mask = sv_meta_p->mask;
-
- for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++)
- {
- if (mask & 1)
- svUsedList[svUsedCount++] = i + svIdOffset;
- mask = mask >> 1;
- }
-
- if (svUsedCount == 0 && LOC_GNSS_CONSTELLATION_GPS != sv_meta_p->svType)
- return 0;
-
- if (svUsedCount == 0)
- fixType = '1'; // no fix
- else if (svUsedCount <= 3)
- fixType = '2'; // 2D fix
- else
- fixType = '3'; // 3D fix
-
- // Start printing the sentence
- // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc
- // a : Mode : A : Automatic, allowed to automatically switch 2D/3D
- // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix)
- // xx : 12 SV ID
- // p.p : Position DOP (Dilution of Precision)
- // h.h : Horizontal DOP
- // v.v : Vertical DOP
- // cc : Checksum value
- length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", talker, fixType);
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return 0;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- // Add first 12 satellite IDs
- for (uint8_t i = 0; i < 12; i++)
- {
- if (i < svUsedCount)
- length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]);
- else
- length = snprintf(pMarker, lengthRemaining, ",");
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return 0;
- }
- pMarker += length;
- lengthRemaining -= length;
- }
-
- // Add the position/horizontal/vertical DOP values
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP)
- { // dop is in locationExtended, (QMI)
- length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f",
- locationExtended.pdop,
- locationExtended.hdop,
- locationExtended.vdop);
- }
- else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0)
- { // dop was cached from sv report (RPC)
- length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f",
- loc_eng_data_p->pdop,
- loc_eng_data_p->hdop,
- loc_eng_data_p->vdop);
- }
- else
- { // no dop
- length = snprintf(pMarker, lengthRemaining, ",,");
- }
-
- /* Sentence is ready, add checksum and broadcast */
- length = loc_eng_nmea_put_checksum(sentence, bufSize);
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- return svUsedCount;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_generate_GSV
-
-DESCRIPTION
- Generate NMEA GSV sentences generated based on sv report
- Currently below sentences are generated:
- - $GPGSV: GPS Satellites in View
- - $GNGSV: GLONASS Satellites in View
- - $GAGSV: GALILEO Satellites in View
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- NONE
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_nmea_generate_GSV(loc_eng_data_s_type *loc_eng_data_p,
- const LocGnssSvStatus &svStatus,
- char* sentence,
- int bufSize,
- loc_nmea_sv_meta* sv_meta_p)
-{
- if (!loc_eng_data_p || !sentence || bufSize <= 0)
- {
- LOC_LOGE("NMEA Error invalid argument.");
- return;
- }
-
- char* pMarker = sentence;
- int lengthRemaining = bufSize;
- int length = 0;
- int sentenceCount = 0;
- int sentenceNumber = 1;
- int svNumber = 1;
-
- const char* talker = sv_meta_p->talker;
- uint32_t svIdOffset = sv_meta_p->svIdOffset;
- uint32_t mask = sv_meta_p->mask;
- uint32_t svCount = loc_eng_nmea_count_bits(mask);
-
-
- if (svCount <= 0)
- {
- // no svs in view, so just send a blank $--GSV sentence
- snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", talker);
- length = loc_eng_nmea_put_checksum(sentence, bufSize);
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
- return;
- }
-
- svNumber = 1;
- sentenceNumber = 1;
- sentenceCount = svCount / 4 + (svCount % 4 != 0);
-
- while (sentenceNumber <= sentenceCount)
- {
- pMarker = sentence;
- lengthRemaining = bufSize;
-
- length = snprintf(pMarker, lengthRemaining, "$%sGSV,%d,%d,%02d",
- talker, sentenceCount, sentenceNumber, svCount);
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- for (int i=0; (svNumber <= svStatus.num_svs) && (i < 4); svNumber++)
- {
- if (sv_meta_p->svType == svStatus.gnss_sv_list[svNumber - 1].constellation)
- {
- length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,",
- svStatus.gnss_sv_list[svNumber - 1].svid,
- (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].elevation), //float to int
- (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].azimuth)); //float to int
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz > 0)
- {
- length = snprintf(pMarker, lengthRemaining,"%02d",
- (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz)); //float to int
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
- }
-
- i++;
- }
-
- }
-
- length = loc_eng_nmea_put_checksum(sentence, bufSize);
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
- sentenceNumber++;
-
- } //while
-}
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_generate_pos
-
-DESCRIPTION
- Generate NMEA sentences generated based on position report
- Currently below sentences are generated within this function:
- - $GPGSA : GPS DOP and active SVs
- - $GLGSA : GLONASS DOP and active SVs
- - $GAGSA : GALILEO DOP and active SVs
- - $GNGSA : GNSS DOP and active SVs
- - $--VTG : Track made good and ground speed
- - $--RMC : Recommended minimum navigation information
- - $--GGA : Time, position and fix related data
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p,
- const UlpLocation &location,
- const GpsLocationExtended &locationExtended,
- unsigned char generate_nmea)
-{
- ENTRY_LOG();
- time_t utcTime(location.gpsLocation.timestamp/1000);
- tm * pTm = gmtime(&utcTime);
- if (NULL == pTm) {
- LOC_LOGE("gmtime failed");
- return;
- }
-
- char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
- char* pMarker = sentence;
- int lengthRemaining = sizeof(sentence);
- int length = 0;
- int utcYear = pTm->tm_year % 100; // 2 digit year
- int utcMonth = pTm->tm_mon + 1; // tm_mon starts at zero
- int utcDay = pTm->tm_mday;
- int utcHours = pTm->tm_hour;
- int utcMinutes = pTm->tm_min;
- int utcSeconds = pTm->tm_sec;
- int utcMSeconds = (location.gpsLocation.timestamp)%1000;
-
- if (generate_nmea) {
- char talker[3] = {'G', 'P', '\0'};
- uint32_t svUsedCount = 0;
- uint32_t count = 0;
- loc_nmea_sv_meta sv_meta;
- // -------------------
- // ---$GPGSA/$GNGSA---
- // -------------------
-
- count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GPS, true));
- if (count > 0)
- {
- svUsedCount += count;
- talker[1] = sv_meta.talker[1];
- }
-
- // -------------------
- // ---$GLGSA/$GNGSA---
- // -------------------
-
- count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GLONASS, true));
- if (count > 0)
- {
- svUsedCount += count;
- talker[1] = sv_meta.talker[1];
- }
-
- // -------------------
- // ---$GAGSA/$GNGSA---
- // -------------------
-
- count = loc_eng_nmea_generate_GSA(loc_eng_data_p, locationExtended, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GALILEO, true));
- if (count > 0)
- {
- svUsedCount += count;
- talker[1] = sv_meta.talker[1];
- }
-
- // -------------------
- // ------$--VTG-------
- // -------------------
-
- pMarker = sentence;
- lengthRemaining = sizeof(sentence);
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING)
- {
- float magTrack = location.gpsLocation.bearing;
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV)
- {
- float magTrack = location.gpsLocation.bearing - locationExtended.magneticDeviation;
- if (magTrack < 0.0)
- magTrack += 360.0;
- else if (magTrack > 360.0)
- magTrack -= 360.0;
- }
-
- length = snprintf(pMarker, lengthRemaining, "$%sVTG,%.1lf,T,%.1lf,M,", talker, location.gpsLocation.bearing, magTrack);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining, "$%sVTG,,T,,M,", talker);
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED)
- {
- float speedKnots = location.gpsLocation.speed * (3600.0/1852.0);
- float speedKmPerHour = location.gpsLocation.speed * 3.6;
-
- length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining, ",N,,K,");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
- // N means no fix
- length = snprintf(pMarker, lengthRemaining, "%c", 'N');
- else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
- // D means differential
- length = snprintf(pMarker, lengthRemaining, "%c", 'D');
- else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
- // E means estimated (dead reckoning)
- length = snprintf(pMarker, lengthRemaining, "%c", 'E');
- else // A means autonomous
- length = snprintf(pMarker, lengthRemaining, "%c", 'A');
-
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- // -------------------
- // ------$--RMC-------
- // -------------------
-
- pMarker = sentence;
- lengthRemaining = sizeof(sentence);
-
- length = snprintf(pMarker, lengthRemaining, "$%sRMC,%02d%02d%02d.%02d,A," ,
- talker, utcHours, utcMinutes, utcSeconds,utcMSeconds/10);
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)
- {
- double latitude = location.gpsLocation.latitude;
- double longitude = location.gpsLocation.longitude;
- char latHemisphere;
- char lonHemisphere;
- double latMinutes;
- double lonMinutes;
-
- if (latitude > 0)
- {
- latHemisphere = 'N';
- }
- else
- {
- latHemisphere = 'S';
- latitude *= -1.0;
- }
-
- if (longitude < 0)
- {
- lonHemisphere = 'W';
- longitude *= -1.0;
- }
- else
- {
- lonHemisphere = 'E';
- }
-
- latMinutes = fmod(latitude * 60.0 , 60.0);
- lonMinutes = fmod(longitude * 60.0 , 60.0);
-
- length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,",
- (uint8_t)floor(latitude), latMinutes, latHemisphere,
- (uint8_t)floor(longitude),lonMinutes, lonHemisphere);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining,",,,,");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED)
- {
- float speedKnots = location.gpsLocation.speed * (3600.0/1852.0);
- length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining, ",");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING)
- {
- length = snprintf(pMarker, lengthRemaining, "%.1lf,", location.gpsLocation.bearing);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining, ",");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,",
- utcDay, utcMonth, utcYear);
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV)
- {
- float magneticVariation = locationExtended.magneticDeviation;
- char direction;
- if (magneticVariation < 0.0)
- {
- direction = 'W';
- magneticVariation *= -1.0;
- }
- else
- {
- direction = 'E';
- }
-
- length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,",
- magneticVariation, direction);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining, ",,");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
- // N means no fix
- length = snprintf(pMarker, lengthRemaining, "%c", 'N');
- else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
- // D means differential
- length = snprintf(pMarker, lengthRemaining, "%c", 'D');
- else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
- // E means estimated (dead reckoning)
- length = snprintf(pMarker, lengthRemaining, "%c", 'E');
- else // A means autonomous
- length = snprintf(pMarker, lengthRemaining, "%c", 'A');
-
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- // -------------------
- // ------$--GGA-------
- // -------------------
-
- pMarker = sentence;
- lengthRemaining = sizeof(sentence);
-
- length = snprintf(pMarker, lengthRemaining, "$%sGGA,%02d%02d%02d.%02d," ,
- talker, utcHours, utcMinutes, utcSeconds, utcMSeconds/10);
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)
- {
- double latitude = location.gpsLocation.latitude;
- double longitude = location.gpsLocation.longitude;
- char latHemisphere;
- char lonHemisphere;
- double latMinutes;
- double lonMinutes;
-
- if (latitude > 0)
- {
- latHemisphere = 'N';
- }
- else
- {
- latHemisphere = 'S';
- latitude *= -1.0;
- }
-
- if (longitude < 0)
- {
- lonHemisphere = 'W';
- longitude *= -1.0;
- }
- else
- {
- lonHemisphere = 'E';
- }
-
- latMinutes = fmod(latitude * 60.0 , 60.0);
- lonMinutes = fmod(longitude * 60.0 , 60.0);
-
- length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,",
- (uint8_t)floor(latitude), latMinutes, latHemisphere,
- (uint8_t)floor(longitude),lonMinutes, lonHemisphere);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining,",,,,");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- char gpsQuality;
- if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG))
- gpsQuality = '0'; // 0 means no fix
- else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask)
- gpsQuality = '2'; // 2 means DGPS fix
- else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask)
- gpsQuality = '6'; // 6 means estimated (dead reckoning)
- else
- gpsQuality = '1'; // 1 means GPS fix
-
- // Number of satellites in use, 00-12
- if (svUsedCount > MAX_SATELLITES_IN_USE)
- svUsedCount = MAX_SATELLITES_IN_USE;
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP)
- { // dop is in locationExtended, (QMI)
- length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,",
- gpsQuality, svUsedCount, locationExtended.hdop);
- }
- else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0)
- { // dop was cached from sv report (RPC)
- length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,",
- gpsQuality, svUsedCount, loc_eng_data_p->hdop);
- }
- else
- { // no hdop
- length = snprintf(pMarker, lengthRemaining, "%c,%02d,,",
- gpsQuality, svUsedCount);
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)
- {
- length = snprintf(pMarker, lengthRemaining, "%.1lf,M,",
- locationExtended.altitudeMeanSeaLevel);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining,",,");
- }
-
- if (length < 0 || length >= lengthRemaining)
- {
- LOC_LOGE("NMEA Error in string formatting");
- return;
- }
- pMarker += length;
- lengthRemaining -= length;
-
- if ((location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ALTITUDE) &&
- (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL))
- {
- length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,",
- location.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel);
- }
- else
- {
- length = snprintf(pMarker, lengthRemaining,",,,");
- }
-
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- // clear the cache so they can't be used again
- loc_eng_data_p->gps_used_mask = 0;
- loc_eng_data_p->glo_used_mask = 0;
- loc_eng_data_p->gal_used_mask = 0;
- }
- //Send blank NMEA reports for non-final fixes
- else {
- strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence));
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence));
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence));
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence));
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
-
- strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence));
- length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence));
- loc_eng_nmea_send(sentence, length, loc_eng_data_p);
- }
- // clear the dop cache so they can't be used again
- loc_eng_data_p->pdop = 0;
- loc_eng_data_p->hdop = 0;
- loc_eng_data_p->vdop = 0;
-
- EXIT_LOG(%d, 0);
-}
-
-
-
-/*===========================================================================
-FUNCTION loc_eng_nmea_generate_sv
-
-DESCRIPTION
- Generate NMEA sentences generated based on sv report
-
-DEPENDENCIES
- NONE
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p,
- const LocGnssSvStatus &svStatus, const GpsLocationExtended &locationExtended)
-{
- ENTRY_LOG();
-
- char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0};
- char* pMarker = sentence;
- int lengthRemaining = sizeof(sentence);
- int length = 0;
- int svCount = svStatus.num_svs;
- int sentenceCount = 0;
- int sentenceNumber = 1;
- int svNumber = 1;
-
- //Count GPS SVs for saparating GPS from GLONASS and throw others
-
- loc_eng_data_p->gps_used_mask = 0;
- loc_eng_data_p->glo_used_mask = 0;
- loc_eng_data_p->gal_used_mask = 0;
- for(svNumber=1; svNumber <= svCount; svNumber++) {
- if (LOC_GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation)
- {
- // cache the used in fix mask, as it will be needed to send $GPGSA
- // during the position report
- if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX))
- {
- loc_eng_data_p->gps_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1));
- }
- }
- else if (LOC_GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation)
- {
- // cache the used in fix mask, as it will be needed to send $GNGSA
- // during the position report
- if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX))
- {
- loc_eng_data_p->glo_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1));
- }
- }
- else if (LOC_GNSS_CONSTELLATION_GALILEO == svStatus.gnss_sv_list[svNumber - 1].constellation)
- {
- // cache the used in fix mask, as it will be needed to send $GAGSA
- // during the position report
- if (LOC_GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & LOC_GNSS_SV_FLAGS_USED_IN_FIX))
- {
- loc_eng_data_p->gal_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1));
- }
- }
- }
-
- loc_nmea_sv_meta sv_meta;
- // ------------------
- // ------$GPGSV------
- // ------------------
-
- loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GPS, false));
-
- // ------------------
- // ------$GLGSV------
- // ------------------
-
- loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GLONASS, false));
-
- // ------------------
- // ------$GAGSV------
- // ------------------
-
- loc_eng_nmea_generate_GSV(loc_eng_data_p, svStatus, sentence, sizeof(sentence),
- loc_nmea_sv_meta_init(loc_eng_data_p, sv_meta, LOC_GNSS_CONSTELLATION_GALILEO, false));
-
-
- // For RPC, the DOP are sent during sv report, so cache them
- // now to be sent during position report.
- // For QMI, the DOP will be in position report.
- if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP)
- {
- loc_eng_data_p->pdop = locationExtended.pdop;
- loc_eng_data_p->hdop = locationExtended.hdop;
- loc_eng_data_p->vdop = locationExtended.vdop;
- }
- else
- {
- loc_eng_data_p->pdop = 0;
- loc_eng_data_p->hdop = 0;
- loc_eng_data_p->vdop = 0;
- }
-
- EXIT_LOG(%d, 0);
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.h b/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.h
deleted file mode 100644
index 9480a6a..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_nmea.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright (c) 2012, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_NMEA_H
-#define LOC_ENG_NMEA_H
-
-#include <gps_extended.h>
-
-#define NMEA_SENTENCE_MAX_LENGTH 200
-
-void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p);
-int loc_eng_nmea_put_checksum(char *pNmea, int maxSize);
-void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const LocGnssSvStatus &svStatus, const GpsLocationExtended &locationExtended);
-void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, const UlpLocation &location, const GpsLocationExtended &locationExtended, unsigned char generate_nmea);
-
-#endif // LOC_ENG_NMEA_H
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.cpp
deleted file mode 100644
index b5bf4e7..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.cpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/* Copyright (c) 2009-2014, The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation, nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_eng"
-
-#include <loc_eng.h>
-#include <MsgTask.h>
-#include <platform_lib_includes.h>
-
-using namespace loc_core;
-
-struct LocEngRequestXtraServer : public LocMsg {
- LocEngAdapter* mAdapter;
- inline LocEngRequestXtraServer(LocEngAdapter* adapter) :
- LocMsg(), mAdapter(adapter)
- {
- locallog();
- }
- inline virtual void proc() const {
- mAdapter->requestXtraServer();
- }
- inline void locallog() const {
- LOC_LOGV("LocEngRequestXtraServer");
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-struct LocEngInjectXtraData : public LocMsg {
- LocEngAdapter* mAdapter;
- char* mData;
- const int mLen;
- inline LocEngInjectXtraData(LocEngAdapter* adapter,
- char* data, int len):
- LocMsg(), mAdapter(adapter),
- mData(new char[len]), mLen(len)
- {
- memcpy((void*)mData, (void*)data, len);
- locallog();
- }
- inline ~LocEngInjectXtraData()
- {
- delete[] mData;
- }
- inline virtual void proc() const {
- mAdapter->setXtraData(mData, mLen);
- }
- inline void locallog() const {
- LOC_LOGV("length: %d\n data: %p", mLen, mData);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-struct LocEngSetXtraVersionCheck : public LocMsg {
- LocEngAdapter *mAdapter;
- int mCheck;
- inline LocEngSetXtraVersionCheck(LocEngAdapter* adapter,
- int check):
- mAdapter(adapter), mCheck(check) {}
- inline virtual void proc() const {
- locallog();
- mAdapter->setXtraVersionCheck(mCheck);
- }
- inline void locallog() const {
- LOC_LOGD("%s:%d]: mCheck: %d",
- __func__, __LINE__, mCheck);
- }
- inline virtual void log() const {
- locallog();
- }
-};
-
-/*===========================================================================
-FUNCTION loc_eng_xtra_init
-
-DESCRIPTION
- Initialize XTRA module.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- 0: success
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data,
- GpsXtraExtCallbacks* callbacks)
-{
- int ret_val = -1;
- loc_eng_xtra_data_s_type *xtra_module_data_ptr;
- ENTRY_LOG();
-
- if(!loc_eng_data.adapter->mSupportsTimeInjection
- || loc_eng_data.adapter->hasNativeXtraClient()) {
- LOC_LOGD("XTRA is already supported. disable it here.\n");
- EXIT_LOG(%d, 1); // return 1 denote failure
- return 1;
- }
-
- if(callbacks == NULL) {
- LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL");
- } else {
- xtra_module_data_ptr = &loc_eng_data.xtra_module_data;
- xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb;
- xtra_module_data_ptr->report_xtra_server_cb = callbacks->report_xtra_server_cb;
-
- ret_val = 0;
- }
- EXIT_LOG(%d, ret_val);
- return ret_val;
-}
-
-/*===========================================================================
-FUNCTION loc_eng_xtra_inject_data
-
-DESCRIPTION
- Injects XTRA file into the engine but buffers the data if engine is busy.
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data,
- char* data, int length)
-{
- ENTRY_LOG();
- LocEngAdapter* adapter = loc_eng_data.adapter;
- adapter->sendMsg(new LocEngInjectXtraData(adapter, data, length));
- EXIT_LOG(%d, 0);
- return 0;
-}
-/*===========================================================================
-FUNCTION loc_eng_xtra_request_server
-
-DESCRIPTION
- Request the Xtra server url from the modem
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- 0
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data)
-{
- ENTRY_LOG();
- LocEngAdapter* adapter = loc_eng_data.adapter;
- adapter->sendMsg(new LocEngRequestXtraServer(adapter));
- EXIT_LOG(%d, 0);
- return 0;
-}
-/*===========================================================================
-FUNCTION loc_eng_xtra_version_check
-
-DESCRIPTION
- Injects the enable/disable value for checking XTRA version
- that is specified in gps.conf
-
-DEPENDENCIES
- N/A
-
-RETURN VALUE
- none
-
-SIDE EFFECTS
- N/A
-
-===========================================================================*/
-void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data,
- int check)
-{
- ENTRY_LOG();
- LocEngAdapter *adapter = loc_eng_data.adapter;
- adapter->sendMsg(new LocEngSetXtraVersionCheck(adapter, check));
- EXIT_LOG(%d, 0);
-}
diff --git a/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.h b/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.h
deleted file mode 100644
index 41a006f..0000000
--- a/msm8998/loc_api/libloc_api_50001/loc_eng_xtra.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright (c) 2009,2011 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#ifndef LOC_ENG_XTRA_H
-#define LOC_ENG_XTRA_H
-
-// Module data
-typedef struct
-{
- // loc_eng_ioctl_cb_data_s_type ioctl_cb_data;
- loc_gps_xtra_download_request download_request_cb;
- report_xtra_server report_xtra_server_cb;
-
- // XTRA data buffer
- char *xtra_data_for_injection; // NULL if no pending data
- int xtra_data_len;
-} loc_eng_xtra_data_s_type;
-
-#endif // LOC_ENG_XTRA_H
diff --git a/msm8998/location/Android.mk b/msm8998/location/Android.mk
new file mode 100644
index 0000000..49a60d7
--- /dev/null
+++ b/msm8998/location/Android.mk
@@ -0,0 +1,41 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := liblocation_api
+LOCAL_MODULE_OWNER := qti
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ libgps.utils \
+ libdl \
+ liblog
+
+LOCAL_SRC_FILES += \
+ LocationAPI.cpp \
+ LocationAPIClientBase.cpp
+
+LOCAL_CFLAGS += \
+ -fno-short-enums
+
+LOCAL_C_INCLUDES:= \
+ $(TARGET_OUT_HEADERS)/gps.utils
+
+LOCAL_COPY_HEADERS_TO:= liblocation_api/
+LOCAL_COPY_HEADERS:= \
+ LocationAPI.h \
+ LocationAPIClientBase.h \
+ location_interface.h
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/msm8998/location/LocationAPI.cpp b/msm8998/location/LocationAPI.cpp
new file mode 100644
index 0000000..c800851
--- /dev/null
+++ b/msm8998/location/LocationAPI.cpp
@@ -0,0 +1,675 @@
+/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#define LOG_TAG "LocSvc_LocationAPI"
+
+#include <location_interface.h>
+#include <dlfcn.h>
+#include <log_util.h>
+#include <pthread.h>
+#include <map>
+
+typedef void* (getLocationInterface)();
+typedef std::map<LocationAPI*, LocationCallbacks> LocationClientMap;
+typedef struct {
+ LocationClientMap clientData;
+ LocationControlAPI* controlAPI;
+ LocationControlCallbacks controlCallbacks;
+ GnssInterface* gnssInterface;
+ GeofenceInterface* geofenceInterface;
+ FlpInterface* flpInterface;
+} LocationAPIData;
+static LocationAPIData gData = {};
+static pthread_mutex_t gDataMutex = PTHREAD_MUTEX_INITIALIZER;
+static bool gGnssLoadFailed = false;
+static bool gFlpLoadFailed = false;
+static bool gGeofenceLoadFailed = false;
+
+static bool needsGnssTrackingInfo(LocationCallbacks& locationCallbacks)
+{
+ return (locationCallbacks.gnssLocationInfoCb != nullptr ||
+ locationCallbacks.gnssSvCb != nullptr ||
+ locationCallbacks.gnssNmeaCb != nullptr ||
+ locationCallbacks.gnssMeasurementsCb != nullptr);
+}
+
+static bool isGnssClient(LocationCallbacks& locationCallbacks)
+{
+ return (locationCallbacks.gnssNiCb != nullptr ||
+ locationCallbacks.trackingCb != nullptr ||
+ locationCallbacks.gnssMeasurementsCb != nullptr);
+}
+
+static bool isFlpClient(LocationCallbacks& locationCallbacks)
+{
+ return (locationCallbacks.trackingCb != nullptr ||
+ locationCallbacks.batchingCb != nullptr);
+}
+
+static bool isGeofenceClient(LocationCallbacks& locationCallbacks)
+{
+ return (locationCallbacks.geofenceBreachCb != nullptr ||
+ locationCallbacks.geofenceStatusCb != nullptr);
+}
+
+static void* loadLocationInterface(const char* library, const char* name) {
+ LOC_LOGD("%s]: loading %s::%s ...", __func__, library, name);
+ if (NULL == library || NULL == name) {
+ return NULL;
+ }
+ getLocationInterface* getter = NULL;
+ const char *error;
+ dlerror();
+ void *handle = dlopen(library, RTLD_NOW);
+ if (NULL == handle || (error = dlerror()) != NULL) {
+ LOC_LOGW("dlopen for %s failed, error = %s", library, error);
+ } else {
+ getter = (getLocationInterface*)dlsym(handle, name);
+ if ((error = dlerror()) != NULL) {
+ LOC_LOGW("dlsym for %s::%s failed, error = %s", library, name, error);
+ getter = NULL;
+ }
+ }
+
+ if (NULL == getter) {
+ return (void*)getter;
+ } else {
+ return (*getter)();
+ }
+}
+
+LocationAPI*
+LocationAPI::createInstance(LocationCallbacks& locationCallbacks)
+{
+ if (nullptr == locationCallbacks.capabilitiesCb ||
+ nullptr == locationCallbacks.responseCb ||
+ nullptr == locationCallbacks.collectiveResponseCb) {
+ return NULL;
+ }
+
+ LocationAPI* newLocationAPI = new LocationAPI();
+ bool requestedCapabilities = false;
+
+ pthread_mutex_lock(&gDataMutex);
+
+ if (isGnssClient(locationCallbacks)) {
+ if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
+ gData.gnssInterface =
+ (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
+ if (NULL == gData.gnssInterface) {
+ gGnssLoadFailed = true;
+ LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
+ } else {
+ gData.gnssInterface->initialize();
+ }
+ }
+ if (NULL != gData.gnssInterface) {
+ gData.gnssInterface->addClient(newLocationAPI, locationCallbacks);
+ if (!requestedCapabilities) {
+ gData.gnssInterface->requestCapabilities(newLocationAPI);
+ requestedCapabilities = true;
+ }
+ }
+ }
+
+ if (isFlpClient(locationCallbacks)) {
+ if (NULL == gData.flpInterface && !gFlpLoadFailed) {
+ gData.flpInterface =
+ (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface");
+ if (NULL == gData.flpInterface) {
+ gFlpLoadFailed = true;
+ LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__);
+ } else {
+ gData.flpInterface->initialize();
+ }
+ }
+ if (NULL != gData.flpInterface) {
+ gData.flpInterface->addClient(newLocationAPI, locationCallbacks);
+ if (!requestedCapabilities) {
+ gData.flpInterface->requestCapabilities(newLocationAPI);
+ requestedCapabilities = true;
+ }
+ }
+ }
+
+ if (isGeofenceClient(locationCallbacks)) {
+ if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) {
+ gData.geofenceInterface =
+ (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface");
+ if (NULL == gData.geofenceInterface) {
+ gGeofenceLoadFailed = true;
+ LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__);
+ } else {
+ gData.geofenceInterface->initialize();
+ }
+ }
+ if (NULL != gData.geofenceInterface) {
+ gData.geofenceInterface->addClient(newLocationAPI, locationCallbacks);
+ if (!requestedCapabilities) {
+ gData.geofenceInterface->requestCapabilities(newLocationAPI);
+ requestedCapabilities = true;
+ }
+ }
+ }
+
+ gData.clientData[newLocationAPI] = locationCallbacks;
+
+ pthread_mutex_unlock(&gDataMutex);
+
+ return newLocationAPI;
+}
+
+void
+LocationAPI::destroy()
+{
+ delete this;
+}
+
+LocationAPI::LocationAPI()
+{
+ LOC_LOGD("LOCATION API CONSTRUCTOR");
+}
+
+LocationAPI::~LocationAPI()
+{
+ LOC_LOGD("LOCATION API DESTRUCTOR");
+ pthread_mutex_lock(&gDataMutex);
+
+ auto it = gData.clientData.find(this);
+ if (it != gData.clientData.end()) {
+ size_t gnssClientCount = 0;
+ size_t flpClientCount = 0;
+ size_t geofenceClientCount = 0;
+ for (auto it2=gData.clientData.begin(); it2 != gData.clientData.end(); ++it2) {
+ if (isGnssClient(it2->second)) {
+ gnssClientCount++;
+ }
+ if (isFlpClient(it2->second)) {
+ flpClientCount++;
+ }
+ if (isGeofenceClient(it2->second)) {
+ geofenceClientCount++;
+ }
+ }
+ if (isGnssClient(it->second) && NULL != gData.gnssInterface) {
+ gData.gnssInterface->removeClient(it->first);
+ if (1 == gnssClientCount && NULL == gData.controlAPI) {
+ gData.gnssInterface->deinitialize();
+ }
+ }
+ if (isFlpClient(it->second) && NULL != gData.flpInterface) {
+ gData.flpInterface->removeClient(it->first);
+ if (1 == flpClientCount) {
+ gData.flpInterface->deinitialize();
+ }
+ }
+ if (isGeofenceClient(it->second) && NULL != gData.geofenceInterface) {
+ gData.geofenceInterface->removeClient(it->first);
+ if (1 == geofenceClientCount) {
+ gData.geofenceInterface->deinitialize();
+ }
+ }
+ gData.clientData.erase(it);
+ } else {
+ LOC_LOGE("%s:%d]: Location API client %p not found in client data",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::updateCallbacks(LocationCallbacks& locationCallbacks)
+{
+ if (nullptr == locationCallbacks.capabilitiesCb ||
+ nullptr == locationCallbacks.responseCb ||
+ nullptr == locationCallbacks.collectiveResponseCb) {
+ return;
+ }
+
+ pthread_mutex_lock(&gDataMutex);
+
+ if (isGnssClient(locationCallbacks)) {
+ if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
+ gData.gnssInterface =
+ (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
+ if (NULL == gData.gnssInterface) {
+ gGnssLoadFailed = true;
+ LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
+ } else {
+ gData.gnssInterface->initialize();
+ }
+ }
+ if (NULL != gData.gnssInterface) {
+ // either adds new Client or updates existing Client
+ gData.gnssInterface->addClient(this, locationCallbacks);
+ }
+ }
+
+ if (isFlpClient(locationCallbacks)) {
+ if (NULL == gData.flpInterface && !gFlpLoadFailed) {
+ gData.flpInterface =
+ (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface");
+ if (NULL == gData.flpInterface) {
+ gFlpLoadFailed = true;
+ LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__);
+ } else {
+ gData.flpInterface->initialize();
+ }
+ }
+ if (NULL != gData.flpInterface) {
+ // either adds new Client or updates existing Client
+ gData.flpInterface->addClient(this, locationCallbacks);
+ }
+ }
+
+ if (isGeofenceClient(locationCallbacks)) {
+ if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) {
+ gData.geofenceInterface =
+ (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface");
+ if (NULL == gData.geofenceInterface) {
+ gGeofenceLoadFailed = true;
+ LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__);
+ } else {
+ gData.geofenceInterface->initialize();
+ }
+ }
+ if (NULL != gData.geofenceInterface) {
+ // either adds new Client or updates existing Client
+ gData.geofenceInterface->addClient(this, locationCallbacks);
+ }
+ }
+
+ gData.clientData[this] = locationCallbacks;
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+uint32_t
+LocationAPI::startTracking(LocationOptions& locationOptions)
+{
+ uint32_t id = 0;
+ pthread_mutex_lock(&gDataMutex);
+
+ auto it = gData.clientData.find(this);
+ if (it != gData.clientData.end()) {
+ if (gData.flpInterface != NULL && locationOptions.minDistance > 0) {
+ id = gData.flpInterface->startTracking(this, locationOptions);
+ } else if (gData.gnssInterface != NULL && needsGnssTrackingInfo(it->second)) {
+ id = gData.gnssInterface->startTracking(this, locationOptions);
+ } else if (gData.flpInterface != NULL) {
+ id = gData.flpInterface->startTracking(this, locationOptions);
+ } else if (gData.gnssInterface != NULL) {
+ id = gData.gnssInterface->startTracking(this, locationOptions);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+ } else {
+ LOC_LOGE("%s:%d]: Location API client %p not found in client data",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return id;
+}
+
+void
+LocationAPI::stopTracking(uint32_t id)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ auto it = gData.clientData.find(this);
+ if (it != gData.clientData.end()) {
+ // we don't know if tracking was started on flp or gnss, so we call stop on both, where
+ // stopTracking call to the incorrect interface will fail without response back to client
+ if (gData.gnssInterface != NULL) {
+ gData.gnssInterface->stopTracking(this, id);
+ }
+ if (gData.flpInterface != NULL) {
+ gData.flpInterface->stopTracking(this, id);
+ }
+ if (gData.flpInterface != NULL && gData.gnssInterface != NULL) {
+ LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+ } else {
+ LOC_LOGE("%s:%d]: Location API client %p not found in client data",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ auto it = gData.clientData.find(this);
+ if (it != gData.clientData.end()) {
+ // we don't know if tracking was started on flp or gnss, so we call update on both, where
+ // updateTracking call to the incorrect interface will fail without response back to client
+ if (gData.gnssInterface != NULL) {
+ gData.gnssInterface->updateTrackingOptions(this, id, locationOptions);
+ }
+ if (gData.flpInterface != NULL) {
+ gData.flpInterface->updateTrackingOptions(this, id, locationOptions);
+ }
+ if (gData.flpInterface != NULL && gData.gnssInterface != NULL) {
+ LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+ } else {
+ LOC_LOGE("%s:%d]: Location API client %p not found in client data",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+uint32_t
+LocationAPI::startBatching(LocationOptions& locationOptions)
+{
+ uint32_t id = 0;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.flpInterface != NULL) {
+ id = gData.flpInterface->startBatching(this, locationOptions);
+ } else {
+ LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return id;
+}
+
+void
+LocationAPI::stopBatching(uint32_t id)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.flpInterface != NULL) {
+ gData.flpInterface->stopBatching(this, id);
+ } else {
+ LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::updateBatchingOptions(uint32_t id, LocationOptions& locationOptions)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.flpInterface != NULL) {
+ gData.flpInterface->updateBatchingOptions(this,
+ id,
+ locationOptions);
+ } else {
+ LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::getBatchedLocations(uint32_t id, size_t count)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.flpInterface != NULL) {
+ gData.flpInterface->getBatchedLocations(this, id, count);
+ } else {
+ LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+uint32_t*
+LocationAPI::addGeofences(size_t count, GeofenceOption* options, GeofenceInfo* info)
+{
+ uint32_t* ids = NULL;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.geofenceInterface != NULL) {
+ ids = gData.geofenceInterface->addGeofences(this, count, options, info);
+ } else {
+ LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return ids;
+}
+
+void
+LocationAPI::removeGeofences(size_t count, uint32_t* ids)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.geofenceInterface != NULL) {
+ gData.geofenceInterface->removeGeofences(this, count, ids);
+ } else {
+ LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.geofenceInterface != NULL) {
+ gData.geofenceInterface->modifyGeofences(this, count, ids, options);
+ } else {
+ LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::pauseGeofences(size_t count, uint32_t* ids)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.geofenceInterface != NULL) {
+ gData.geofenceInterface->pauseGeofences(this, count, ids);
+ } else {
+ LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::resumeGeofences(size_t count, uint32_t* ids)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.geofenceInterface != NULL) {
+ gData.geofenceInterface->resumeGeofences(this, count, ids);
+ } else {
+ LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+void
+LocationAPI::gnssNiResponse(uint32_t id, GnssNiResponse response)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.gnssInterface != NULL) {
+ gData.gnssInterface->gnssNiResponse(this, id, response);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss interface available for Location API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+LocationControlAPI*
+LocationControlAPI::createInstance(LocationControlCallbacks& locationControlCallbacks)
+{
+ LocationControlAPI* controlAPI = NULL;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (nullptr != locationControlCallbacks.responseCb && NULL == gData.controlAPI) {
+ if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
+ gData.gnssInterface =
+ (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
+ if (NULL == gData.gnssInterface) {
+ gGnssLoadFailed = true;
+ LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
+ } else {
+ gData.gnssInterface->initialize();
+ }
+ }
+ if (NULL != gData.gnssInterface) {
+ gData.controlAPI = new LocationControlAPI();
+ gData.controlCallbacks = locationControlCallbacks;
+ gData.gnssInterface->setControlCallbacks(locationControlCallbacks);
+ controlAPI = gData.controlAPI;
+ }
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return controlAPI;
+}
+
+void
+LocationControlAPI::destroy()
+{
+ delete this;
+}
+
+LocationControlAPI::LocationControlAPI()
+{
+ LOC_LOGD("LOCATION CONTROL API CONSTRUCTOR");
+}
+
+LocationControlAPI::~LocationControlAPI()
+{
+ LOC_LOGD("LOCATION CONTROL API DESTRUCTOR");
+ pthread_mutex_lock(&gDataMutex);
+
+ size_t gnssClientCount = 0;
+ for (auto it=gData.clientData.begin(); it != gData.clientData.end(); ++it) {
+ if (isGnssClient(it->second)) {
+ gnssClientCount++;
+ }
+ }
+ if (gData.gnssInterface != NULL && 0 == gnssClientCount) {
+ //@todo: we might want to call gData.gnssInterface.disable before deinitialize?
+ gData.gnssInterface->deinitialize();
+ }
+ gData.controlAPI = NULL;
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+uint32_t
+LocationControlAPI::enable(LocationTechnologyType techType)
+{
+ uint32_t id = 0;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.gnssInterface != NULL) {
+ id = gData.gnssInterface->enable(techType);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return id;
+}
+
+void
+LocationControlAPI::disable(uint32_t id)
+{
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.gnssInterface != NULL) {
+ gData.gnssInterface->disable(id);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+}
+
+uint32_t*
+LocationControlAPI::gnssUpdateConfig(GnssConfig config)
+{
+ uint32_t* ids = NULL;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.gnssInterface != NULL) {
+ ids = gData.gnssInterface->gnssUpdateConfig(config);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return ids;
+}
+
+uint32_t
+LocationControlAPI::gnssDeleteAidingData(GnssAidingData& data)
+{
+ uint32_t id = 0;
+ pthread_mutex_lock(&gDataMutex);
+
+ if (gData.gnssInterface != NULL) {
+ id = gData.gnssInterface->gnssDeleteAidingData(data);
+ } else {
+ LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
+ __func__, __LINE__, this);
+ }
+
+ pthread_mutex_unlock(&gDataMutex);
+ return id;
+}
diff --git a/msm8998/location/LocationAPI.h b/msm8998/location/LocationAPI.h
new file mode 100644
index 0000000..cc15ddd
--- /dev/null
+++ b/msm8998/location/LocationAPI.h
@@ -0,0 +1,866 @@
+/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOCATION_H
+#define LOCATION_H
+
+#include <stdint.h>
+#include <functional>
+
+#define GNSS_NI_REQUESTOR_MAX 256
+#define GNSS_NI_MESSAGE_ID_MAX 2048
+#define GNSS_SV_MAX 64
+#define GNSS_MEASUREMENTS_MAX 64
+
+typedef enum {
+ LOCATION_ERROR_SUCCESS = 0,
+ LOCATION_ERROR_GENERAL_FAILURE,
+ LOCATION_ERROR_CALLBACK_MISSING,
+ LOCATION_ERROR_INVALID_PARAMETER,
+ LOCATION_ERROR_ID_EXISTS,
+ LOCATION_ERROR_ID_UNKNOWN,
+ LOCATION_ERROR_ALREADY_STARTED,
+ LOCATION_ERROR_GEOFENCES_AT_MAX,
+ LOCATION_ERROR_NOT_SUPPORTED
+} LocationError;
+
+// Flags to indicate which values are valid in a Location
+typedef uint16_t LocationFlagsMask;
+typedef enum {
+ LOCATION_HAS_LAT_LONG_BIT = (1<<0), // location has valid latitude and longitude
+ LOCATION_HAS_ALTITUDE_BIT = (1<<1), // location has valid altitude
+ LOCATION_HAS_SPEED_BIT = (1<<2), // location has valid speed
+ LOCATION_HAS_BEARING_BIT = (1<<3), // location has valid bearing
+ LOCATION_HAS_ACCURACY_BIT = (1<<4), // location has valid accuracy
+} LocationFlagsBits;
+
+typedef uint16_t LocationTechnologyMask;
+typedef enum {
+ LOCATION_TECHNOLOGY_GNSS_BIT = (1<<0), // location was calculated using GNSS
+ LOCATION_TECHNOLOGY_CELL_BIT = (1<<1), // location was calculated using Cell
+ LOCATION_TECHNOLOGY_WIFI_BIT = (1<<2), // location was calculated using WiFi
+ LOCATION_TECHNOLOGY_SENSORS_BIT = (1<<3), // location was calculated using Sensors
+} LocationTechnologyBits;
+
+typedef enum {
+ LOCATION_RELIABILITY_NOT_SET = 0,
+ LOCATION_RELIABILITY_VERY_LOW,
+ LOCATION_RELIABILITY_LOW,
+ LOCATION_RELIABILITY_MEDIUM,
+ LOCATION_RELIABILITY_HIGH,
+} LocationReliability;
+
+typedef uint32_t GnssLocationInfoFlagMask;
+typedef enum {
+ GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT = (1<<0), // valid altitude mean sea level
+ GNSS_LOCATION_INFO_DOP_BIT = (1<<1), // valid pdop, hdop, and vdop
+ GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT = (1<<2), // valid magnetic deviation
+ GNSS_LOCATION_INFO_VER_ACCURACY_BIT = (1<<3), // valid vertical accuracy
+ GNSS_LOCATION_INFO_SPEED_ACCURACY_BIT = (1<<4), // valid speed accuracy
+ GNSS_LOCATION_INFO_BEARING_ACCURACY_BIT = (1<<5), // valid bearing accuracy
+ GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT = (1<<6), // valid horizontal reliability
+ GNSS_LOCATION_INFO_VER_RELIABILITY_BIT = (1<<7), // valid vertical reliability
+ GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT = (1<<8), // valid elipsode semi major
+ GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT = (1<<9), // valid elipsode semi minor
+ GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<10),// valid accuracy elipsode azimuth
+} GnssLocationInfoFlagBits;
+
+typedef enum {
+ GEOFENCE_BREACH_ENTER = 0,
+ GEOFENCE_BREACH_EXIT,
+ GEOFENCE_BREACH_DWELL_IN,
+ GEOFENCE_BREACH_DWELL_OUT,
+ GEOFENCE_BREACH_UNKNOWN,
+} GeofenceBreachType;
+
+typedef uint16_t GeofenceBreachTypeMask;
+typedef enum {
+ GEOFENCE_BREACH_ENTER_BIT = (1<<0),
+ GEOFENCE_BREACH_EXIT_BIT = (1<<1),
+ GEOFENCE_BREACH_DWELL_IN_BIT = (1<<2),
+ GEOFENCE_BREACH_DWELL_OUT_BIT = (1<<3),
+} GeofenceBreachTypeBits;
+
+typedef enum {
+ GEOFENCE_STATUS_AVAILABILE_NO = 0,
+ GEOFENCE_STATUS_AVAILABILE_YES,
+} GeofenceStatusAvailable;
+
+typedef uint32_t LocationCapabilitiesMask;
+typedef enum {
+ // supports startTracking API with minInterval param
+ LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT = (1<<0),
+ // supports startBatching API with minInterval param
+ LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT = (1<<1),
+ // supports startTracking API with minDistance param
+ LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT = (1<<2),
+ // supports startBatching API with minDistance param
+ LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT = (1<<3),
+ // supports addGeofences API
+ LOCATION_CAPABILITIES_GEOFENCE_BIT = (1<<4),
+ // supports GnssMeasurementsCallback
+ LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT = (1<<5),
+ // supports startTracking/startBatching API with LocationOptions.mode of MSB (Ms Based)
+ LOCATION_CAPABILITIES_GNSS_MSB_BIT = (1<<6),
+ // supports startTracking/startBatching API with LocationOptions.mode of MSA (MS Assisted)
+ LOCATION_CAPABILITIES_GNSS_MSA_BIT = (1<<7),
+} LocationCapabilitiesBits;
+
+typedef enum {
+ LOCATION_TECHNOLOGY_TYPE_GNSS = 0,
+} LocationTechnologyType;
+
+// Configures how GPS is locked when GPS is disabled (through GnssDisable)
+typedef enum {
+ GNSS_CONFIG_GPS_LOCK_NONE = 0, // gps is not locked when GPS is disabled (GnssDisable)
+ GNSS_CONFIG_GPS_LOCK_MO, // gps mobile originated (MO) is locked when GPS is disabled
+ GNSS_CONFIG_GPS_LOCK_NI, // gps network initiated (NI) is locked when GPS is disabled
+ GNSS_CONFIG_GPS_LOCK_MO_AND_NI,// gps MO and NI is locked when GPS is disabled
+} GnssConfigGpsLock;
+
+// SUPL version
+typedef enum {
+ GNSS_CONFIG_SUPL_VERSION_1_0_0 = 1,
+ GNSS_CONFIG_SUPL_VERSION_2_0_0,
+ GNSS_CONFIG_SUPL_VERSION_2_0_2,
+} GnssConfigSuplVersion;
+
+// LTE Positioning Profile
+typedef enum {
+ GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE = 0, // RRLP on LTE (Default)
+ GNSS_CONFIG_LPP_PROFILE_USER_PLANE, // LPP User Plane (UP) on LTE
+ GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE, // LPP_Control_Plane (CP)
+ GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE, // Both LPP UP and CP
+} GnssConfigLppProfile;
+
+// Technology for LPPe Control Plane
+typedef uint16_t GnssConfigLppeControlPlaneMask;
+typedef enum {
+ GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT = (1<<0), // DBH
+ GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS
+} GnssConfigLppeControlPlaneBits;
+
+// Technology for LPPe User Plane
+typedef uint16_t GnssConfigLppeUserPlaneMask;
+typedef enum {
+ GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT = (1<<0), // DBH
+ GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS
+} GnssConfigLppeUserPlaneBits;
+
+// Positioning Protocol on A-GLONASS system
+typedef uint16_t GnssConfigAGlonassPositionProtocolMask;
+typedef enum {
+ GNSS_CONFIG_RRC_CONTROL_PLANE_BIT = (1<<0), // RRC Control Plane
+ GNSS_CONFIG_RRLP_USER_PLANE_BIT = (1<<1), // RRLP User Plane
+ GNSS_CONFIG_LLP_USER_PLANE_BIT = (1<<2), // LPP User Plane
+ GNSS_CONFIG_LLP_CONTROL_PLANE_BIT = (1<<3), // LPP Control Plane
+} GnssConfigAGlonassPositionProtocolBits;
+
+typedef enum {
+ GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO = 0,
+ GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES,
+} GnssConfigEmergencyPdnForEmergencySupl;
+
+typedef enum {
+ GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO = 0,
+ GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES,
+} GnssConfigSuplEmergencyServices;
+
+typedef uint16_t GnssConfigSuplModeMask;
+typedef enum {
+ GNSS_CONFIG_SUPL_MODE_MSB = (1<<0),
+ GNSS_CONFIG_SUPL_MODE_MSA = (1<<1),
+} GnssConfigSuplModeBits;
+
+typedef uint32_t GnssConfigFlagsMask;
+typedef enum {
+ GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT = (1<<0),
+ GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT = (1<<1),
+ GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT = (1<<2),
+ GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT = (1<<3),
+ GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT = (1<<4),
+ GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT = (1<<5),
+ GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT = (1<<6),
+ GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT = (1<<7),
+ GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT = (1<<8),
+ GNSS_CONFIG_FLAGS_SUPL_MODE_BIT = (1<<9),
+} GnssConfigFlagsBits;
+
+typedef enum {
+ GNSS_NI_ENCODING_TYPE_NONE = 0,
+ GNSS_NI_ENCODING_TYPE_GSM_DEFAULT,
+ GNSS_NI_ENCODING_TYPE_UTF8,
+ GNSS_NI_ENCODING_TYPE_UCS2,
+} GnssNiEncodingType;
+
+typedef enum {
+ GNSS_NI_TYPE_VOICE = 0,
+ GNSS_NI_TYPE_SUPL,
+ GNSS_NI_TYPE_CONTROL_PLANE,
+ GNSS_NI_TYPE_EMERGENCY_SUPL
+} GnssNiType;
+
+typedef uint16_t GnssNiOptionsMask;
+typedef enum {
+ GNSS_NI_OPTIONS_NOTIFICATION = (1<<0),
+ GNSS_NI_OPTIONS_VERIFICATION = (1<<1),
+ GNSS_NI_OPTIONS_PRIVACY_OVERRIDE = (1<<2),
+} GnssNiOptionsBits;
+
+typedef enum {
+ GNSS_NI_RESPONSE_ACCEPT = 1,
+ GNSS_NI_RESPONSE_DENY,
+ GNSS_NI_RESPONSE_NO_RESPONSE,
+ GNSS_NI_RESPONSE_IGNORE,
+} GnssNiResponse;
+
+typedef enum {
+ GNSS_SV_TYPE_UNKNOWN = 0,
+ GNSS_SV_TYPE_GPS,
+ GNSS_SV_TYPE_SBAS,
+ GNSS_SV_TYPE_GLONASS,
+ GNSS_SV_TYPE_QZSS,
+ GNSS_SV_TYPE_BEIDOU,
+ GNSS_SV_TYPE_GALILEO,
+} GnssSvType;
+
+typedef uint16_t GnssSvOptionsMask;
+typedef enum {
+ GNSS_SV_OPTIONS_HAS_EPHEMER_BIT = (1<<0),
+ GNSS_SV_OPTIONS_HAS_ALMANAC_BIT = (1<<1),
+ GNSS_SV_OPTIONS_USED_IN_FIX_BIT = (1<<2),
+} GnssSvOptionsBits;
+
+typedef enum {
+ GNSS_ASSISTANCE_TYPE_SUPL = 0,
+ GNSS_ASSISTANCE_TYPE_C2K,
+} GnssAssistanceType;
+
+typedef enum {
+ GNSS_SUPL_MODE_STANDALONE = 0,
+ GNSS_SUPL_MODE_MSB,
+ GNSS_SUPL_MODE_MSA,
+} GnssSuplMode;
+
+typedef uint16_t GnssMeasurementsAdrStateMask;
+typedef enum {
+ GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_UNKNOWN = 0,
+ GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT = (1<<0),
+ GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT = (1<<1),
+ GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT = (1<<2),
+} GnssMeasurementsAdrStateBits;
+
+typedef uint32_t GnssMeasurementsDataFlagsMask;
+typedef enum {
+ GNSS_MEASUREMENTS_DATA_SV_ID_BIT = (1<<0),
+ GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT = (1<<1),
+ GNSS_MEASUREMENTS_DATA_STATE_BIT = (1<<2),
+ GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_BIT = (1<<3),
+ GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_UNCERTAINTY_BIT = (1<<4),
+ GNSS_MEASUREMENTS_DATA_CARRIER_TO_NOISE_BIT = (1<<5),
+ GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT = (1<<6),
+ GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT = (1<<7),
+ GNSS_MEASUREMENTS_DATA_ADR_STATE_BIT = (1<<8),
+ GNSS_MEASUREMENTS_DATA_ADR_BIT = (1<<9),
+ GNSS_MEASUREMENTS_DATA_ADR_UNCERTAINTY_BIT = (1<<10),
+ GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT = (1<<11),
+ GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT = (1<<12),
+ GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT = (1<<13),
+ GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT = (1<<14),
+ GNSS_MEASUREMENTS_DATA_MULTIPATH_INDICATOR_BIT = (1<<15),
+ GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT = (1<<16),
+} GnssMeasurementsDataFlagsBits;
+
+typedef uint32_t GnssMeasurementsStateMask;
+typedef enum {
+ GNSS_MEASUREMENTS_STATE_UNKNOWN_BIT = 0,
+ GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT = (1<<0),
+ GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT = (1<<1),
+ GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT = (1<<2),
+ GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT = (1<<3),
+ GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT = (1<<4),
+ GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT = (1<<5),
+ GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT = (1<<6),
+ GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT = (1<<7),
+ GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT = (1<<8),
+ GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT = (1<<9),
+ GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT = (1<<10),
+ GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT = (1<<11),
+ GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT = (1<<12),
+ GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT = (1<<13),
+} GnssMeasurementsStateBits;
+
+typedef enum {
+ GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN = 0,
+ GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT,
+ GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT,
+} GnssMeasurementsMultipathIndicator;
+
+typedef uint32_t GnssMeasurementsClockFlagsMask;
+typedef enum {
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT = (1<<0),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_BIT = (1<<1),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT = (1<<2),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT = (1<<3),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT = (1<<4),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT = (1<<5),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT = (1<<6),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT = (1<<7),
+ GNSS_MEASUREMENTS_CLOCK_FLAGS_HW_CLOCK_DISCONTINUITY_COUNT_BIT = (1<<8),
+} GnssMeasurementsClockFlagsBits;
+
+typedef uint32_t GnssAidingDataSvMask;
+typedef enum {
+ GNSS_AIDING_DATA_SV_EPHEMERIS = (1<<0), // ephemeris
+ GNSS_AIDING_DATA_SV_ALMANAC = (1<<1), // almanac
+ GNSS_AIDING_DATA_SV_HEALTH = (1<<2), // health
+ GNSS_AIDING_DATA_SV_DIRECTION = (1<<3), // direction
+ GNSS_AIDING_DATA_SV_STEER = (1<<4), // steer
+ GNSS_AIDING_DATA_SV_ALMANAC_CORR = (1<<5), // almanac correction
+ GNSS_AIDING_DATA_SV_BLACKLIST = (1<<6), // blacklist SVs
+ GNSS_AIDING_DATA_SV_SA_DATA = (1<<7), // sensitivity assistance data
+ GNSS_AIDING_DATA_SV_NO_EXIST = (1<<8), // SV does not exist
+ GNSS_AIDING_DATA_SV_IONOSPHERE = (1<<9), // ionosphere correction
+ GNSS_AIDING_DATA_SV_TIME = (1<<10),// reset satellite time
+} GnssAidingDataSvBits;
+
+typedef uint32_t GnssAidingDataSvTypeMask;
+typedef enum {
+ GNSS_AIDING_DATA_SV_TYPE_GPS = (1<<0),
+ GNSS_AIDING_DATA_SV_TYPE_GLONASS = (1<<1),
+ GNSS_AIDING_DATA_SV_TYPE_QZSS = (1<<2),
+ GNSS_AIDING_DATA_SV_TYPE_BEIDOU = (1<<3),
+ GNSS_AIDING_DATA_SV_TYPE_GALILEO = (1<<4),
+} GnssAidingDataSvTypeBits;
+
+typedef struct {
+ GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits
+ GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits
+} GnssAidingDataSv;
+
+typedef uint32_t GnssAidingDataCommonMask;
+typedef enum {
+ GNSS_AIDING_DATA_COMMON_POSITION = (1<<0), // position estimate
+ GNSS_AIDING_DATA_COMMON_TIME = (1<<1), // reset all clock values
+ GNSS_AIDING_DATA_COMMON_UTC = (1<<2), // UTC estimate
+ GNSS_AIDING_DATA_COMMON_RTI = (1<<3), // RTI
+ GNSS_AIDING_DATA_COMMON_FREQ_BIAS_EST = (1<<4), // frequency bias estimate
+ GNSS_AIDING_DATA_COMMON_CELLDB = (1<<5), // all celldb info
+} GnssAidingDataCommonBits;
+
+typedef struct {
+ GnssAidingDataCommonMask mask; // bitwise OR of GnssAidingDataCommonBits
+} GnssAidingDataCommon;
+
+typedef struct {
+ bool deleteAll; // if true, delete all aiding data and ignore other params
+ GnssAidingDataSv sv; // SV specific aiding data
+ GnssAidingDataCommon common; // common aiding data
+} GnssAidingData;
+
+typedef struct {
+ size_t size; // set to sizeof(Location)
+ LocationFlagsMask flags; // bitwise OR of LocationFlagsBits to mark which params are valid
+ uint64_t timestamp; // UTC timestamp for location fix, milliseconds since January 1, 1970
+ double latitude; // in degrees
+ double longitude; // in degrees
+ double altitude; // in meters above the WGS 84 reference ellipsoid
+ float speed; // in meters per second
+ float bearing; // in degrees; range [0, 360)
+ float accuracy; // in meters
+ LocationTechnologyMask techMask;
+} Location;
+
+typedef struct {
+ size_t size; // set to sizeof(LocationOptions)
+ uint32_t minInterval; // in milliseconds
+ uint32_t minDistance; // in meters. if minDistance > 0, gnssSvCallback/gnssNmeaCallback/
+ // gnssMeasurementsCallback may not be called
+ GnssSuplMode mode; // Standalone/MS-Based/MS-Assisted
+} LocationOptions;
+
+typedef struct {
+ size_t size; // set to sizeof(GeofenceOption)
+ GeofenceBreachTypeMask breachTypeMask; // bitwise OR of GeofenceBreachTypeBits
+ uint32_t responsiveness; // in milliseconds
+ uint32_t dwellTime; // in seconds
+} GeofenceOption;
+
+typedef struct {
+ size_t size; // set to sizeof(GeofenceInfo)
+ double latitude; // in degrees
+ double longitude; // in degrees
+ double radius; // in meters
+} GeofenceInfo;
+
+typedef struct {
+ size_t size; // set to sizeof(GeofenceBreachNotification)
+ size_t count; // number of ids in array
+ uint32_t* ids; // array of ids that have breached
+ Location location; // location associated with breach
+ GeofenceBreachType type; // type of breach
+ uint64_t timestamp; // timestamp of breach
+} GeofenceBreachNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GeofenceBreachNotification)
+ GeofenceStatusAvailable available; // GEOFENCE_STATUS_AVAILABILE_NO/_YES
+ LocationTechnologyType techType; // GNSS
+} GeofenceStatusNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssLocationInfo)
+ GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity
+ float altitudeMeanSeaLevel; // altitude wrt mean sea level
+ float pdop; // position dilusion of precision
+ float hdop; // horizontal dilusion of precision
+ float vdop; // vertical dilusion of precision
+ float magneticDeviation; // magnetic deviation
+ float verAccuracy; // vertical accuracy in meters
+ float speedAccuracy; // speed accuracy in meters/second
+ float bearingAccuracy; // bearing accuracy in degrees (0 to 359.999)
+ LocationReliability horReliability; // horizontal reliability
+ LocationReliability verReliability; // vertical reliability
+ float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis
+ float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis
+ float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth
+} GnssLocationInfoNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssNiNotification)
+ GnssNiType type; // type of NI (Voice, SUPL, Control Plane)
+ GnssNiOptionsMask options; // bitwise OR of GnssNiOptionsBits
+ uint32_t timeout; // time (seconds) to wait for user input
+ GnssNiResponse timeoutResponse; // the response that should be sent when timeout expires
+ char requestor[GNSS_NI_REQUESTOR_MAX]; // the requestor that is making the request
+ GnssNiEncodingType requestorEncoding; // the encoding type for requestor
+ char message[GNSS_NI_MESSAGE_ID_MAX]; // the message to show user
+ GnssNiEncodingType messageEncoding; // the encoding type for message
+ char extras[GNSS_NI_MESSAGE_ID_MAX];
+} GnssNiNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssSv)
+ uint16_t svId; // Unique Identifier
+ GnssSvType type; // type of SV (GPS, SBAS, GLONASS, QZSS, BEIDOU, GALILEO)
+ float cN0Dbhz; // signal strength
+ float elevation; // elevation of SV (in degrees)
+ float azimuth; // azimuth of SV (in degrees)
+ GnssSvOptionsMask gnssSvOptionsMask; // Bitwise OR of GnssSvOptionsBits
+} GnssSv;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssConfigSetAssistanceServer)
+ GnssAssistanceType type; // SUPL or C2K
+ const char* hostName; // null terminated string
+ uint32_t port; // port of server
+} GnssConfigSetAssistanceServer;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssMeasurementsData)
+ GnssMeasurementsDataFlagsMask flags; // bitwise OR of GnssMeasurementsDataFlagsBits
+ int16_t svId;
+ GnssSvType svType;
+ double timeOffsetNs;
+ GnssMeasurementsStateMask stateMask; // bitwise OR of GnssMeasurementsStateBits
+ int64_t receivedSvTimeNs;
+ int64_t receivedSvTimeUncertaintyNs;
+ double carrierToNoiseDbHz;
+ double pseudorangeRateMps;
+ double pseudorangeRateUncertaintyMps;
+ GnssMeasurementsAdrStateMask adrStateMask; // bitwise OR of GnssMeasurementsAdrStateBits
+ double adrMeters;
+ double adrUncertaintyMeters;
+ float carrierFrequencyHz;
+ int64_t carrierCycles;
+ double carrierPhase;
+ double carrierPhaseUncertainty;
+ GnssMeasurementsMultipathIndicator multipathIndicator;
+ double signalToNoiseRatioDb;
+} GnssMeasurementsData;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssMeasurementsClock)
+ GnssMeasurementsClockFlagsMask flags; // bitwise OR of GnssMeasurementsClockFlagsBits
+ int16_t leapSecond;
+ int64_t timeNs;
+ double timeUncertaintyNs;
+ int64_t fullBiasNs;
+ double biasNs;
+ double biasUncertaintyNs;
+ double driftNsps;
+ double driftUncertaintyNsps;
+ uint32_t hwClockDiscontinuityCount;
+} GnssMeasurementsClock;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssSvNotification)
+ size_t count; // number of SVs in the GnssSv array
+ GnssSv gnssSvs[GNSS_SV_MAX]; // information on a number of SVs
+} GnssSvNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssNmeaNotification)
+ uint64_t timestamp; // timestamp
+ const char* nmea; // nmea text
+ size_t length; // length of the nmea text
+} GnssNmeaNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssMeasurementsNotification)
+ size_t count; // number of items in GnssMeasurements array
+ GnssMeasurementsData measurements[GNSS_MEASUREMENTS_MAX];
+ GnssMeasurementsClock clock; // clock
+} GnssMeasurementsNotification;
+
+typedef struct {
+ size_t size; // set to sizeof(GnssConfig)
+ GnssConfigFlagsMask flags; // bitwise OR of GnssConfigFlagsBits to mark which params are valid
+ GnssConfigGpsLock gpsLock;
+ GnssConfigSuplVersion suplVersion;
+ GnssConfigSetAssistanceServer assistanceServer;
+ GnssConfigLppProfile lppProfile;
+ GnssConfigLppeControlPlaneMask lppeControlPlaneMask;
+ GnssConfigLppeUserPlaneMask lppeUserPlaneMask;
+ GnssConfigAGlonassPositionProtocolMask aGlonassPositionProtocolMask;
+ GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl;
+ GnssConfigSuplEmergencyServices suplEmergencyServices;
+ GnssConfigSuplModeMask suplModeMask; //bitwise OR of GnssConfigSuplModeBits
+} GnssConfig;
+
+/* Provides the capabilities of the system
+ capabilities callback is called once soon after createInstance is called */
+typedef std::function<void(
+ LocationCapabilitiesMask capabilitiesMask // bitwise OR of LocationCapabilitiesBits
+)> capabilitiesCallback;
+
+/* Used by tracking, batching, and miscellanous APIs
+ responseCallback is called for every Tracking, Batching API, and Miscellanous API */
+typedef std::function<void(
+ LocationError err, // if not SUCCESS, then id is not valid
+ uint32_t id // id to be associated to the request
+)> responseCallback;
+
+/* Used by APIs that gets more than one LocationError in it's response
+ collectiveResponseCallback is called for every geofence API call.
+ ids array and LocationError array are only valid until collectiveResponseCallback returns. */
+typedef std::function<void(
+ size_t count, // number of locations in arrays
+ LocationError* errs, // array of LocationError associated to the request
+ uint32_t* ids // array of ids to be associated to the request
+)> collectiveResponseCallback;
+
+/* Used for startTracking API, optional can be NULL
+ trackingCallback is called when delivering a location in a tracking session
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ Location location
+)> trackingCallback;
+
+/* Used for startBatching API, optional can be NULL
+ batchingCallback is called when delivering locations in a batching session.
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ size_t count, // number of locations in array
+ Location* location // array of locations
+)> batchingCallback;
+
+/* Gives GNSS Location information, optional can be NULL
+ gnssLocationInfoCallback is called only during a tracking session
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ GnssLocationInfoNotification gnssLocationInfoNotification
+)> gnssLocationInfoCallback;
+
+/* Used for addGeofences API, optional can be NULL
+ geofenceBreachCallback is called when any number of geofences have a state change */
+typedef std::function<void(
+ GeofenceBreachNotification geofenceBreachNotification
+)> geofenceBreachCallback;
+
+/* Used for addGeofences API, optional can be NULL
+ geofenceStatusCallback is called when any number of geofences have a status change */
+typedef std::function<void(
+ GeofenceStatusNotification geofenceStatusNotification
+)> geofenceStatusCallback;
+
+/* Network Initiated request, optional can be NULL
+ This callback should be responded to by calling gnssNiResponse */
+typedef std::function<void(
+ uint32_t id, // id that should be used to respond by calling gnssNiResponse
+ GnssNiNotification gnssNiNotification
+)> gnssNiCallback;
+
+/* Gives GNSS SV information, optional can be NULL
+ gnssSvCallback is called only during a tracking session
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ GnssSvNotification gnssSvNotification
+)> gnssSvCallback;
+
+/* Gives GNSS NMEA data, optional can be NULL
+ gnssNmeaCallback is called only during a tracking session
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ GnssNmeaNotification gnssNmeaNotification
+)> gnssNmeaCallback;
+
+/* Gives GNSS Measurements information, optional can be NULL
+ gnssMeasurementsCallback is called only during a tracking session
+ broadcasted to all clients, no matter if a session has started by client */
+typedef std::function<void(
+ GnssMeasurementsNotification gnssMeasurementsNotification
+)> gnssMeasurementsCallback;
+
+typedef struct {
+ size_t size; // set to sizeof(LocationCallbacks)
+ capabilitiesCallback capabilitiesCb; // mandatory
+ responseCallback responseCb; // mandatory
+ collectiveResponseCallback collectiveResponseCb; // mandatory
+ trackingCallback trackingCb; // optional
+ batchingCallback batchingCb; // optional
+ geofenceBreachCallback geofenceBreachCb; // optional
+ geofenceStatusCallback geofenceStatusCb; // optional
+ gnssLocationInfoCallback gnssLocationInfoCb; // optional
+ gnssNiCallback gnssNiCb; // optional
+ gnssSvCallback gnssSvCb; // optional
+ gnssNmeaCallback gnssNmeaCb; // optional
+ gnssMeasurementsCallback gnssMeasurementsCb; // optional
+} LocationCallbacks;
+
+class LocationAPI
+{
+private:
+ LocationAPI();
+ ~LocationAPI();
+
+public:
+ /* creates an instance to LocationAPI object.
+ Will return NULL if mandatory parameters are invalid or if the maximum number
+ of instances have been reached */
+ static LocationAPI* createInstance(LocationCallbacks&);
+
+ /* destroy/cleans up the instance, which should be called when LocationAPI object is
+ no longer needed. LocationAPI* returned from createInstance will no longer valid
+ after destroy is called */
+ void destroy();
+
+ /* updates/changes the callbacks that will be called.
+ mandatory callbacks must be present for callbacks to be successfully updated
+ no return value */
+ void updateCallbacks(LocationCallbacks&);
+
+ /* ================================== TRACKING ================================== */
+
+ /* startTracking starts a tracking session, which returns a session id that will be
+ used by the other tracking APIs and also in the responseCallback to match command
+ with response. locations are reported on the trackingCallback passed in createInstance
+ periodically according to LocationOptions.
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if session was successfully started
+ LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress
+ LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed in createInstance
+ LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */
+ uint32_t startTracking(LocationOptions&); // returns session id
+
+ /* stopTracking stops a tracking session associated with id parameter.
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
+ void stopTracking(uint32_t id);
+
+ /* updateTrackingOptions changes the LocationOptions of a tracking session associated with id
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
+ void updateTrackingOptions(uint32_t id, LocationOptions&);
+
+ /* ================================== BATCHING ================================== */
+
+ /* startBatching starts a batching session, which returns a session id that will be
+ used by the other batching APIs and also in the responseCallback to match command
+ with response. locations are reported on the batchingCallback passed in createInstance
+ periodically according to LocationOptions. A batching session starts tracking on
+ the low power processor and delivers them in batches by the batchingCallback when
+ the batch is full or when getBatchedLocations is called. This allows for the processor
+ that calls this API to sleep when the low power processor can batch locations in the
+ backgroup and wake up the processor calling the API only when the batch is full, thus
+ saving power
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if session was successful
+ LOCATION_ERROR_ALREADY_STARTED if a startBatching session is already in progress
+ LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance
+ LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid
+ LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */
+ uint32_t startBatching(LocationOptions&); // returns session id
+
+ /* stopBatching stops a batching session associated with id parameter.
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with batching session */
+ void stopBatching(uint32_t id);
+
+ /* updateBatchingOptions changes the LocationOptions of a batching session associated with id
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
+ void updateBatchingOptions(uint32_t id, LocationOptions&);
+
+ /* getBatchedLocations gets a number of locations that are currently stored/batched
+ on the low power processor, delivered by the batchingCallback passed in createInstance.
+ Location are then deleted from the batch stored on the low power processor.
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful, will be followed by batchingCallback call
+ LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
+ void getBatchedLocations(uint32_t id, size_t count);
+
+ /* ================================== GEOFENCE ================================== */
+
+ /* addGeofences adds any number of geofences and returns an array of geofence ids that
+ will be used by the other geofence APIs and also in the collectiveResponseCallback to
+ match command with response. The geofenceBreachCallback will deliver the status of each
+ geofence according to the GeofenceOption for each. The geofence id array returned will
+ be valid until the collectiveResponseCallback is called and has returned.
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if session was successful
+ LOCATION_ERROR_CALLBACK_MISSING if no geofenceBreachCallback
+ LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
+ LOCATION_ERROR_NOT_SUPPORTED if geofence is not supported */
+ uint32_t* addGeofences(size_t count, GeofenceOption*, GeofenceInfo*); // returns id array
+
+ /* removeGeofences removes any number of geofences. Caller should delete ids array after
+ removeGeofences returneds.
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
+ void removeGeofences(size_t count, uint32_t* ids);
+
+ /* modifyGeofences modifies any number of geofences. Caller should delete ids array after
+ modifyGeofences returns.
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session
+ LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid */
+ void modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options);
+
+ /* pauseGeofences pauses any number of geofences, which is similar to removeGeofences,
+ only that they can be resumed at any time. Caller should delete ids array after
+ pauseGeofences returns.
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
+ void pauseGeofences(size_t count, uint32_t* ids);
+
+ /* resumeGeofences resumes any number of geofences that are currently paused. Caller should
+ delete ids array after resumeGeofences returns.
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
+ void resumeGeofences(size_t count, uint32_t* ids);
+
+ /* ================================== GNSS ====================================== */
+
+ /* gnssNiResponse is called in response to a gnssNiCallback.
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if session was successful
+ LOCATION_ERROR_INVALID_PARAMETER if any parameters in GnssNiResponse are invalid
+ LOCATION_ERROR_ID_UNKNOWN if id does not match a gnssNiCallback */
+ void gnssNiResponse(uint32_t id, GnssNiResponse response);
+};
+
+typedef struct {
+ size_t size; // set to sizeof(LocationControlCallbacks)
+ responseCallback responseCb; // mandatory
+ collectiveResponseCallback collectiveResponseCb; // mandatory
+} LocationControlCallbacks;
+
+class LocationControlAPI
+{
+private:
+ LocationControlAPI();
+ ~LocationControlAPI();
+
+public:
+ /* creates an instance to LocationControlAPI object.
+ Will return NULL if mandatory parameters are invalid or if the maximum number
+ of instances have been reached. Only once instance allowed */
+ static LocationControlAPI* createInstance(LocationControlCallbacks&);
+
+ /* destroy/cleans up the instance, which should be called when LocationControlAPI object is
+ no longer needed. LocationControlAPI* returned from createInstance will no longer valid
+ after destroy is called */
+ void destroy();
+
+ /* enable will enable specific location technology to be used for calculation locations and
+ will effectively start a control session if call is successful, which returns a session id
+ that will be returned in responseCallback to match command with response. The session id is
+ also needed to call the disable command.
+ This effect is global for all clients of LocationAPI
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ALREADY_STARTED if an enable was already called for this techType
+ LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
+ LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
+ uint32_t enable(LocationTechnologyType techType);
+
+ /* disable will disable specific location technology to be used for calculation locations and
+ effectively ends the control session if call is successful.
+ id parameter is the session id that was returned in enable responseCallback for techType.
+ The session id is no longer valid after disable's responseCallback returns success.
+ This effect is global for all clients of LocationAPI
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_ID_UNKNOWN if id was not returned from responseCallback from enable
+ LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
+ void disable(uint32_t id);
+
+ /* gnssUpdateConfig updates the gnss specific configuration, which returns a session id array
+ with an id for each of the bits set in GnssConfig.flags, order from low bits to high bits.
+ The response for each config that is set will be returned in collectiveResponseCallback.
+ The session id array returned will be valid until the collectiveResponseCallback is called
+ and has returned. This effect is global for all clients of LocationAPI
+ collectiveResponseCallback returns:
+ LOCATION_ERROR_SUCCESS if session was successful
+ LOCATION_ERROR_INVALID_PARAMETER if any other parameters are invalid
+ LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
+ uint32_t* gnssUpdateConfig(GnssConfig config);
+
+ /* delete specific gnss aiding data for testing, which returns a session id
+ that will be returned in responseCallback to match command with response.
+ Only allowed in userdebug builds. This effect is global for all clients of LocationAPI
+ responseCallback returns:
+ LOCATION_ERROR_SUCCESS if successful
+ LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
+ LOCATION_ERROR_NOT_SUPPORTED if build is not userdebug */
+ uint32_t gnssDeleteAidingData(GnssAidingData& data);
+};
+
+#endif /* LOCATION_H */
diff --git a/msm8998/location/LocationAPIClientBase.cpp b/msm8998/location/LocationAPIClientBase.cpp
new file mode 100644
index 0000000..3413d3e
--- /dev/null
+++ b/msm8998/location/LocationAPIClientBase.cpp
@@ -0,0 +1,769 @@
+/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define LOG_NDDEBUG 0
+#define LOG_TAG "LocSvc_APIClientBase"
+
+#include <log_util.h>
+#include <loc_cfg.h>
+#include "LocationAPIClientBase.h"
+
+#define FLP_CONF_FILE "/etc/flp.conf"
+
+LocationAPIClientBase::LocationAPIClientBase() :
+ mTrackingCallback(nullptr),
+ mBatchingCallback(nullptr),
+ mGeofenceBreachCallback(nullptr),
+ mLocationAPI(nullptr),
+ mLocationControlAPI(nullptr),
+ mBatchSize(-1)
+{
+
+ // use recursive mutex, in case callback come from the same thread
+ pthread_mutexattr_t attr;
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+ pthread_mutex_init(&mMutex, &attr);
+
+ for (int i = 0; i < REQUEST_MAX; i++) {
+ mRequestQueues[i] = nullptr;
+ }
+
+ memset(&mConfig, 0, sizeof(GnssConfig));
+}
+
+void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallbacks)
+{
+ if (locationCallbacks.geofenceBreachCb != nullptr) {
+ mGeofenceBreachCallback = locationCallbacks.geofenceBreachCb;
+ locationCallbacks.geofenceBreachCb =
+ [this](GeofenceBreachNotification geofenceBreachNotification) {
+ beforeGeofenceBreachCb(geofenceBreachNotification);
+ };
+ }
+
+ locationCallbacks.capabilitiesCb =
+ [this](LocationCapabilitiesMask capabilitiesMask) {
+ onCapabilitiesCb(capabilitiesMask);
+ };
+ locationCallbacks.responseCb = [this](LocationError error, uint32_t id) {
+ onResponseCb(error, id);
+ };
+ locationCallbacks.collectiveResponseCb =
+ [this](size_t count, LocationError* errors, uint32_t* ids) {
+ onCollectiveResponseCb(count, errors, ids);
+ };
+
+ if (mLocationAPI == nullptr ) {
+ mLocationAPI = LocationAPI::createInstance(locationCallbacks);
+ } else {
+ mLocationAPI->updateCallbacks(locationCallbacks);
+ }
+
+ if (mLocationControlAPI == nullptr) {
+ LocationControlCallbacks locationControlCallbacks;
+ locationControlCallbacks.size = sizeof(LocationControlCallbacks);
+
+ locationControlCallbacks.responseCb =
+ [this](LocationError error, uint32_t id) {
+ onCtrlResponseCb(error, id);
+ };
+ locationControlCallbacks.collectiveResponseCb =
+ [this](size_t count, LocationError* errors, uint32_t* ids) {
+ onCtrlCollectiveResponseCb(count, errors, ids);
+ };
+
+ mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks);
+ }
+}
+
+LocationAPIClientBase::~LocationAPIClientBase()
+{
+ if (mLocationAPI) {
+ mLocationAPI->destroy();
+ mLocationAPI = nullptr;
+ }
+ if (mLocationControlAPI) {
+ mLocationControlAPI->destroy();
+ mLocationControlAPI = nullptr;
+ }
+
+ pthread_mutex_lock(&mMutex);
+ for (int i = 0; i < REQUEST_MAX; i++) {
+ if (mRequestQueues[i]) {
+ delete mRequestQueues[i];
+ mRequestQueues[i] = nullptr;
+ }
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ pthread_mutex_destroy(&mMutex);
+}
+
+uint32_t LocationAPIClientBase::locAPIStartTracking(LocationOptions& options)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ delete requests;
+ }
+ uint32_t session = mLocationAPI->startTracking(options);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+ // onResponseCb might be called from other thread immediately after
+ // startTracking returns, so we are not going to unlock mutex
+ // until StartTrackingRequest is pushed into mRequestQueues[REQUEST_TRACKING]
+ requests = new RequestQueue(session);
+ requests->push(new StartTrackingRequest(*this));
+ mRequestQueues[REQUEST_TRACKING] = requests;
+ pthread_mutex_unlock(&mMutex);
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+
+ return retVal;
+}
+
+void LocationAPIClientBase::locAPIStopTracking()
+{
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ uint32_t session = -1;
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ session = requests->getSession();
+ requests->push(new StopTrackingRequest(*this));
+ mLocationAPI->stopTracking(session);
+ }
+ pthread_mutex_unlock(&mMutex);
+ }
+}
+
+void LocationAPIClientBase::locAPIUpdateTrackingOptions(LocationOptions& options)
+{
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ uint32_t session = -1;
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ session = requests->getSession();
+ requests->push(new UpdateTrackingOptionsRequest(*this));
+ mLocationAPI->updateTrackingOptions(session, options);
+ }
+ pthread_mutex_unlock(&mMutex);
+ }
+}
+
+int32_t LocationAPIClientBase::locAPIGetBatchSize()
+{
+ if (mBatchSize == -1) {
+ const loc_param_s_type flp_conf_param_table[] =
+ {
+ {"BATCH_SIZE", &mBatchSize, nullptr, 'n'},
+ };
+ UTIL_READ_CONF(FLP_CONF_FILE, flp_conf_param_table);
+ if (mBatchSize < 0) {
+ // set mBatchSize to 0 if we got an illegal value from config file
+ mBatchSize = 0;
+ }
+ }
+ return mBatchSize;
+}
+
+
+uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t sessionMode,
+ LocationOptions& options)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+
+ if (mSessionMap.find(id) != mSessionMap.end()) {
+ LOC_LOGE("%s:%d] session %d has already started.", __FUNCTION__, __LINE__, id);
+ retVal = LOCATION_ERROR_ALREADY_STARTED;
+ } else {
+ uint32_t trackingSession = 0;
+ uint32_t batchingSession = 0;
+
+ if (sessionMode == SESSION_MODE_ON_FIX) {
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ delete requests;
+ }
+ trackingSession = mLocationAPI->startTracking(options);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession);
+ requests = new RequestQueue(trackingSession);
+ requests->push(new StartTrackingRequest(*this));
+ mRequestQueues[REQUEST_TRACKING] = requests;
+ } else if (sessionMode == SESSION_MODE_ON_FULL) {
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ delete requests;
+ }
+ batchingSession = mLocationAPI->startBatching(options);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, batchingSession);
+ requests = new RequestQueue(batchingSession);
+ requests->push(new StartBatchingRequest(*this));
+ mRequestQueues[REQUEST_BATCHING] = requests;
+ }
+
+ SessionEntity entity;
+ entity.id = id;
+ entity.trackingSession = trackingSession;
+ entity.batchingSession = batchingSession;
+ entity.sessionMode = sessionMode;
+ mSessionMap[id] = entity;
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+
+ pthread_mutex_unlock(&mMutex);
+ }
+
+ return retVal;
+}
+
+uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+
+ if (mSessionMap.find(id) != mSessionMap.end()) {
+ SessionEntity entity = mSessionMap[id];
+
+ uint32_t trackingSession = entity.trackingSession;
+ uint32_t batchingSession = entity.batchingSession;
+ uint32_t sMode = entity.sessionMode;
+
+ mSessionMap.erase(id);
+
+ if (sMode == SESSION_MODE_ON_FIX) {
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ requests->push(new StopTrackingRequest(*this));
+ mLocationAPI->stopTracking(trackingSession);
+ }
+ } else if (sMode == SESSION_MODE_ON_FULL) {
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ requests->push(new StopBatchingRequest(*this));
+ mLocationAPI->stopBatching(batchingSession);
+ }
+ }
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ } else {
+ retVal = LOCATION_ERROR_ID_UNKNOWN;
+ LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
+ }
+
+ pthread_mutex_unlock(&mMutex);
+ }
+ return retVal;
+}
+
+uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
+ LocationOptions& options)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+
+ if (mSessionMap.find(id) != mSessionMap.end()) {
+ SessionEntity& entity = mSessionMap[id];
+
+ uint32_t trackingSession = entity.trackingSession;
+ uint32_t batchingSession = entity.batchingSession;
+ uint32_t sMode = entity.sessionMode;
+
+ if (sessionMode == SESSION_MODE_ON_FIX) {
+ if (sMode == SESSION_MODE_ON_FIX) {
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ requests->push(new UpdateTrackingOptionsRequest(*this));
+ mLocationAPI->updateTrackingOptions(trackingSession, options);
+ }
+ } else if (sMode == SESSION_MODE_ON_FULL) {
+ // stop batching
+ {
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ requests->push(new StopBatchingRequest(*this));
+ mLocationAPI->stopBatching(batchingSession);
+ batchingSession = 0;
+ }
+ }
+ // start tracking
+ {
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ delete requests;
+ }
+ trackingSession = mLocationAPI->startTracking(options);
+ LOC_LOGI("%s:%d] start new session: %d",
+ __FUNCTION__, __LINE__, trackingSession);
+ requests = new RequestQueue(trackingSession);
+ requests->push(new StartTrackingRequest(*this));
+ mRequestQueues[REQUEST_TRACKING] = requests;
+ }
+ }
+ } else if (sessionMode == SESSION_MODE_ON_FULL) {
+ if (sMode == SESSION_MODE_ON_FIX) {
+ // stop tracking
+ {
+ RequestQueue* requests = mRequestQueues[REQUEST_TRACKING];
+ if (requests) {
+ requests->push(new StopTrackingRequest(*this));
+ mLocationAPI->stopTracking(trackingSession);
+ trackingSession = 0;
+ }
+ }
+ // start batching
+ {
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ delete requests;
+ }
+ batchingSession = mLocationAPI->startBatching(options);
+ LOC_LOGI("%s:%d] start new session: %d",
+ __FUNCTION__, __LINE__, batchingSession);
+ requests = new RequestQueue(batchingSession);
+ requests->push(new StartBatchingRequest(*this));
+ mRequestQueues[REQUEST_BATCHING] = requests;
+ }
+ } else if (sMode == SESSION_MODE_ON_FULL) {
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ requests->push(new UpdateBatchingOptionsRequest(*this));
+ mLocationAPI->updateBatchingOptions(batchingSession, options);
+ }
+ }
+ }
+
+ entity.trackingSession = trackingSession;
+ entity.batchingSession = batchingSession;
+ entity.sessionMode = sessionMode;
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ } else {
+ retVal = LOCATION_ERROR_ID_UNKNOWN;
+ LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
+ }
+
+ pthread_mutex_unlock(&mMutex);
+ }
+ return retVal;
+}
+
+void LocationAPIClientBase::locAPIGetBatchedLocations(size_t count)
+{
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ uint32_t session = -1;
+ RequestQueue* requests = mRequestQueues[REQUEST_BATCHING];
+ if (requests) {
+ session = requests->getSession();
+ requests->push(new GetBatchedLocationsRequest(*this));
+ mLocationAPI->getBatchedLocations(session, count);
+ }
+ pthread_mutex_unlock(&mMutex);
+ }
+}
+
+uint32_t LocationAPIClientBase::locAPIAddGeofences(
+ size_t count, uint32_t* ids, GeofenceOption* options, GeofenceInfo* data)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ delete requests;
+ }
+ uint32_t* sessions = mLocationAPI->addGeofences(count, options, data);
+ LOC_LOGI("%s:%d] start new sessions: %p", __FUNCTION__, __LINE__, sessions);
+ requests = new RequestQueue(-1);
+ requests->push(new AddGeofencesRequest(*this));
+ mRequestQueues[REQUEST_GEOFENCE] = requests;
+
+ for (size_t i = 0; i < count; i++) {
+ mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+
+ return retVal;
+}
+
+void LocationAPIClientBase::locAPIRemoveGeofences(size_t count, uint32_t* ids)
+{
+ if (mLocationAPI) {
+ uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
+
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ for (size_t i = 0; i < count; i++) {
+ sessions[i] = mGeofenceBiDict.getSession(ids[i]);
+ }
+ requests->push(new RemoveGeofencesRequest(*this));
+ mLocationAPI->removeGeofences(count, sessions);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ free(sessions);
+ }
+}
+
+void LocationAPIClientBase::locAPIModifyGeofences(
+ size_t count, uint32_t* ids, GeofenceOption* options)
+{
+ if (mLocationAPI) {
+ uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
+
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ for (size_t i = 0; i < count; i++) {
+ sessions[i] = mGeofenceBiDict.getSession(ids[i]);
+ mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask);
+ }
+ requests->push(new ModifyGeofencesRequest(*this));
+ mLocationAPI->modifyGeofences(count, sessions, options);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ free(sessions);
+ }
+}
+
+void LocationAPIClientBase::locAPIPauseGeofences(size_t count, uint32_t* ids)
+{
+ if (mLocationAPI) {
+ uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
+
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ for (size_t i = 0; i < count; i++) {
+ sessions[i] = mGeofenceBiDict.getSession(ids[i]);
+ }
+ requests->push(new PauseGeofencesRequest(*this));
+ mLocationAPI->pauseGeofences(count, sessions);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ free(sessions);
+ }
+}
+
+void LocationAPIClientBase::locAPIResumeGeofences(
+ size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask)
+{
+ if (mLocationAPI) {
+ uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
+
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ for (size_t i = 0; i < count; i++) {
+ sessions[i] = mGeofenceBiDict.getSession(ids[i]);
+ if (mask) {
+ mGeofenceBiDict.set(ids[i], sessions[i], mask[i]);
+ }
+ }
+ requests->push(new ResumeGeofencesRequest(*this));
+ mLocationAPI->resumeGeofences(count, sessions);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ free(sessions);
+ }
+}
+
+void LocationAPIClientBase::locAPIRemoveAllGeofences()
+{
+ if (mLocationAPI) {
+ std::vector<uint32_t> sessionsVec = mGeofenceBiDict.getAllSessions();
+ size_t count = sessionsVec.size();
+ uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
+
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_GEOFENCE];
+ if (requests) {
+ for (size_t i = 0; i < count; i++) {
+ sessions[i] = sessionsVec[i];
+ }
+ requests->push(new RemoveGeofencesRequest(*this));
+ mLocationAPI->removeGeofences(count, sessions);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ free(sessions);
+ }
+}
+
+void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse response)
+{
+ uint32_t session = 0;
+ if (mLocationAPI) {
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_NIRESPONSE];
+ if (requests) {
+ delete requests;
+ }
+ uint32_t session = id;
+ mLocationAPI->gnssNiResponse(id, response);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+ requests = new RequestQueue(session);
+ requests->push(new GnssNiResponseRequest(*this));
+ mRequestQueues[REQUEST_NIRESPONSE] = requests;
+ pthread_mutex_unlock(&mMutex);
+ }
+}
+
+uint32_t LocationAPIClientBase::locAPIGnssDeleteAidingData(GnssAidingData& data)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationControlAPI) {
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_DELETEAIDINGDATA];
+ if (requests) {
+ delete requests;
+ }
+ uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+ requests = new RequestQueue(session);
+ requests->push(new GnssDeleteAidingDataRequest(*this));
+ mRequestQueues[REQUEST_DELETEAIDINGDATA] = requests;
+ pthread_mutex_unlock(&mMutex);
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+
+ return retVal;
+}
+
+uint32_t LocationAPIClientBase::locAPIEnable(LocationTechnologyType techType)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (mLocationControlAPI) {
+ pthread_mutex_lock(&mMutex);
+ RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
+ if (requests) {
+ delete requests;
+ }
+ uint32_t session = mLocationControlAPI->enable(techType);
+ LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
+ requests = new RequestQueue(session);
+ requests->push(new EnableRequest(*this));
+ mRequestQueues[REQUEST_CONTROL] = requests;
+ pthread_mutex_unlock(&mMutex);
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+
+ return retVal;
+}
+
+void LocationAPIClientBase::locAPIDisable()
+{
+ if (mLocationControlAPI) {
+ pthread_mutex_lock(&mMutex);
+ uint32_t session = -1;
+ RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
+ if (requests) {
+ session = requests->getSession();
+ requests->push(new DisableRequest(*this));
+ mLocationControlAPI->disable(session);
+ }
+ pthread_mutex_unlock(&mMutex);
+ }
+}
+
+uint32_t LocationAPIClientBase::locAPIGnssUpdateConfig(GnssConfig config)
+{
+ uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
+ if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) {
+ LOC_LOGE("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__);
+ return retVal;
+ }
+
+ if (mLocationControlAPI) {
+ pthread_mutex_lock(&mMutex);
+
+ memcpy(&mConfig, &config, sizeof(GnssConfig));
+
+ uint32_t session = -1;
+ RequestQueue* requests = mRequestQueues[REQUEST_CONTROL];
+ if (requests) {
+ session = requests->getSession();
+ requests->push(new GnssUpdateConfigRequest(*this));
+ uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config);
+ LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray);
+ }
+ pthread_mutex_unlock(&mMutex);
+
+ retVal = LOCATION_ERROR_SUCCESS;
+ }
+ return retVal;
+}
+
+void LocationAPIClientBase::beforeGeofenceBreachCb(
+ GeofenceBreachNotification geofenceBreachNotification)
+{
+ if (mGeofenceBreachCallback == nullptr)
+ return;
+ uint32_t* ids = (uint32_t*)malloc(sizeof(uint32_t) * geofenceBreachNotification.count);
+ uint32_t* backup = geofenceBreachNotification.ids;
+ size_t n = geofenceBreachNotification.count;
+
+ size_t count = 0;
+ for (size_t i = 0; i < n; i++) {
+ uint32_t id = mGeofenceBiDict.getId(geofenceBreachNotification.ids[i]);
+ GeofenceBreachTypeMask type = mGeofenceBiDict.getType(geofenceBreachNotification.ids[i]);
+ if ((geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER &&
+ (type & GEOFENCE_BREACH_ENTER_BIT)) ||
+ (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT &&
+ (type & GEOFENCE_BREACH_EXIT_BIT))
+ ) {
+ ids[count] = id;
+ count++;
+ }
+ }
+ geofenceBreachNotification.count = count;
+ geofenceBreachNotification.ids = ids;
+ mGeofenceBreachCallback(geofenceBreachNotification);
+
+ // restore ids
+ geofenceBreachNotification.ids = backup;
+ geofenceBreachNotification.count = n;
+ free(ids);
+}
+
+void LocationAPIClientBase::onResponseCb(LocationError error, uint32_t id)
+{
+ if (error != LOCATION_ERROR_SUCCESS) {
+ LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
+ } else {
+ LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
+ }
+ LocationAPIRequest* request = getRequestBySession(id);
+ if (request) {
+ request->onResponse(error);
+ delete request;
+ }
+}
+
+void LocationAPIClientBase::onCollectiveResponseCb(
+ size_t count, LocationError* errors, uint32_t* ids)
+{
+ for (size_t i = 0; i < count; i++) {
+ if (errors[i] != LOCATION_ERROR_SUCCESS) {
+ LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+ } else {
+ LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+ }
+ }
+ LocationAPIRequest* request = nullptr;
+ if (count > 0 && ids)
+ request = getRequestBySession(ids[0]);
+ if (!request)
+ request = getGeofencesRequest();
+ if (request) {
+ request->onCollectiveResponse(count, errors, ids);
+ delete request;
+ }
+}
+
+void LocationAPIClientBase::onCtrlResponseCb(LocationError error, uint32_t id)
+{
+ if (error != LOCATION_ERROR_SUCCESS) {
+ LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
+ } else {
+ LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, error, id);
+ }
+ LocationAPIRequest* request = getRequestBySession(id);
+ if (request) {
+ request->onResponse(error);
+ delete request;
+ }
+}
+
+void LocationAPIClientBase::onCtrlCollectiveResponseCb(
+ size_t count, LocationError* errors, uint32_t* ids)
+{
+ for (size_t i = 0; i < count; i++) {
+ if (errors[i] != LOCATION_ERROR_SUCCESS) {
+ LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+ } else {
+ LOC_LOGV("%s:%d] error: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
+ }
+ }
+ LocationAPIRequest* request = nullptr;
+ if (count > 0 && ids)
+ request = getRequestBySession(ids[0]);
+ if (request) {
+ request->onCollectiveResponse(count, errors, ids);
+ delete request;
+ }
+}
+
+LocationAPIClientBase::LocationAPIRequest*
+LocationAPIClientBase::getRequestBySession(uint32_t session)
+{
+ pthread_mutex_lock(&mMutex);
+ LocationAPIRequest* request = nullptr;
+ for (int i = 0; i < REQUEST_MAX; i++) {
+ if (i != REQUEST_GEOFENCE &&
+ mRequestQueues[i] &&
+ mRequestQueues[i]->getSession() == session) {
+ request = mRequestQueues[i]->pop();
+ break;
+ }
+ }
+ pthread_mutex_unlock(&mMutex);
+ return request;
+}
+
+LocationAPIClientBase::LocationAPIRequest*
+LocationAPIClientBase::getGeofencesRequest()
+{
+ pthread_mutex_lock(&mMutex);
+ LocationAPIRequest* request = nullptr;
+ if (mRequestQueues[REQUEST_GEOFENCE]) {
+ request = mRequestQueues[REQUEST_GEOFENCE]->pop();
+ }
+ pthread_mutex_unlock(&mMutex);
+ return request;
+}
diff --git a/msm8998/location/LocationAPIClientBase.h b/msm8998/location/LocationAPIClientBase.h
new file mode 100644
index 0000000..8bbaa3d
--- /dev/null
+++ b/msm8998/location/LocationAPIClientBase.h
@@ -0,0 +1,457 @@
+/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOCATION_API_CLINET_BASE_H
+#define LOCATION_API_CLINET_BASE_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <queue>
+#include <map>
+
+#include "LocationAPI.h"
+
+enum SESSION_MODE {
+ SESSION_MODE_NONE = 0,
+ SESSION_MODE_ON_FULL,
+ SESSION_MODE_ON_FIX,
+};
+
+enum REQUEST_TYPE {
+ REQUEST_TRACKING = 0,
+ REQUEST_BATCHING,
+ REQUEST_GEOFENCE,
+ REQUEST_NIRESPONSE,
+ REQUEST_DELETEAIDINGDATA,
+ REQUEST_CONTROL,
+ REQUEST_MAX,
+};
+
+class LocationAPIClientBase
+{
+public:
+ LocationAPIClientBase();
+ virtual ~LocationAPIClientBase();
+ LocationAPIClientBase(const LocationAPIClientBase&) = delete;
+ LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete;
+
+ void locAPISetCallbacks(LocationCallbacks& locationCallbacks);
+
+ // LocationAPI
+ uint32_t locAPIStartTracking(LocationOptions& options);
+ void locAPIStopTracking();
+ void locAPIUpdateTrackingOptions(LocationOptions& options);
+
+ int32_t locAPIGetBatchSize();
+ uint32_t locAPIStartSession(uint32_t id, uint32_t sessionMode,
+ LocationOptions& options);
+ uint32_t locAPIStopSession(uint32_t id);
+ uint32_t locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
+ LocationOptions& options);
+ void locAPIGetBatchedLocations(size_t count);
+
+ uint32_t locAPIAddGeofences(size_t count, uint32_t* ids,
+ GeofenceOption* options, GeofenceInfo* data);
+ void locAPIRemoveGeofences(size_t count, uint32_t* ids);
+ void locAPIModifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options);
+ void locAPIPauseGeofences(size_t count, uint32_t* ids);
+ void locAPIResumeGeofences(size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask);
+ void locAPIRemoveAllGeofences();
+
+ void locAPIGnssNiResponse(uint32_t id, GnssNiResponse response);
+ uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data);
+
+ uint32_t locAPIEnable(LocationTechnologyType techType);
+ void locAPIDisable();
+ uint32_t locAPIGnssUpdateConfig(GnssConfig config);
+
+ // callbacks
+ void onResponseCb(LocationError error, uint32_t id);
+ void onCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
+
+ void onCtrlResponseCb(LocationError error, uint32_t id);
+ void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
+
+ void beforeGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification);
+
+ inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {}
+ inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {}
+ inline virtual void onGnssMeasurementsCb(
+ GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {}
+
+ inline virtual void onTrackingCb(Location /*location*/) {}
+ inline virtual void onGnssSvCb(GnssSvNotification /*gnssSvNotification*/) {}
+ inline virtual void onStartTrackingCb(LocationError /*error*/) {}
+ inline virtual void onStopTrackingCb(LocationError /*error*/) {}
+ inline virtual void onUpdateTrackingOptionsCb(LocationError /*error*/) {}
+
+ inline virtual void onGnssLocationInfoCb(
+ GnssLocationInfoNotification /*gnssLocationInfoNotification*/) {}
+
+ inline virtual void onBatchingCb(size_t /*count*/, Location* /*location*/) {}
+ inline virtual void onStartBatchingCb(LocationError /*error*/) {}
+ inline virtual void onStopBatchingCb(LocationError /*error*/) {}
+ inline virtual void onUpdateBatchingOptionsCb(LocationError /*error*/) {}
+ inline virtual void onGetBatchedLocationsCb(LocationError /*error*/) {}
+
+ inline virtual void onGeofenceBreachCb(
+ GeofenceBreachNotification /*geofenceBreachNotification*/) {}
+ inline virtual void onGeofenceStatusCb(
+ GeofenceStatusNotification /*geofenceStatusNotification*/) {}
+ inline virtual void onAddGeofencesCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+ inline virtual void onRemoveGeofencesCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+ inline virtual void onModifyGeofencesCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+ inline virtual void onPauseGeofencesCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+ inline virtual void onResumeGeofencesCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+
+ inline virtual void onGnssNiCb(uint32_t /*id*/, GnssNiNotification /*gnssNiNotification*/) {}
+ inline virtual void onGnssNiResponseCb(LocationError /*error*/) {}
+ inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {}
+
+ inline virtual void onEnableCb(LocationError /*error*/) {}
+ inline virtual void onDisableCb(LocationError /*error*/) {}
+ inline virtual void onGnssUpdateConfigCb(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
+
+private:
+ // private inner classes
+ typedef struct {
+ uint32_t id;
+ uint32_t trackingSession;
+ uint32_t batchingSession;
+ uint32_t sessionMode;
+ } SessionEntity;
+
+ class BiDict {
+ public:
+ BiDict() {
+ pthread_mutex_init(&mBiDictMutex, nullptr);
+ }
+ ~BiDict() {
+ pthread_mutex_destroy(&mBiDictMutex);
+ }
+ bool hasId(uint32_t id) {
+ pthread_mutex_lock(&mBiDictMutex);
+ bool ret = (mForwardMap.find(id) != mForwardMap.end());
+ pthread_mutex_unlock(&mBiDictMutex);
+ return ret;
+ }
+ void set(uint32_t id, uint32_t session, uint32_t type) {
+ pthread_mutex_lock(&mBiDictMutex);
+ mForwardMap[id] = session;
+ mBackwardMap[session] = id;
+ mTypeMap[session] = type;
+ pthread_mutex_unlock(&mBiDictMutex);
+ }
+ void clear() {
+ pthread_mutex_lock(&mBiDictMutex);
+ mForwardMap.clear();
+ mBackwardMap.clear();
+ mTypeMap.clear();
+ pthread_mutex_unlock(&mBiDictMutex);
+ }
+ void rmById(uint32_t id) {
+ pthread_mutex_lock(&mBiDictMutex);
+ mBackwardMap.erase(mForwardMap[id]);
+ mTypeMap.erase(mForwardMap[id]);
+ mForwardMap.erase(id);
+ pthread_mutex_unlock(&mBiDictMutex);
+ }
+ void rmBySession(uint32_t session) {
+ pthread_mutex_lock(&mBiDictMutex);
+ mForwardMap.erase(mBackwardMap[session]);
+ mBackwardMap.erase(session);
+ mTypeMap.erase(session);
+ pthread_mutex_unlock(&mBiDictMutex);
+ }
+ uint32_t getId(uint32_t session) {
+ pthread_mutex_lock(&mBiDictMutex);
+ uint32_t ret = mBackwardMap[session];
+ pthread_mutex_unlock(&mBiDictMutex);
+ return ret;
+ }
+ uint32_t getSession(uint32_t id) {
+ pthread_mutex_lock(&mBiDictMutex);
+ uint32_t ret = mForwardMap[id];
+ pthread_mutex_unlock(&mBiDictMutex);
+ return ret;
+ }
+ uint32_t getType(uint32_t session) {
+ pthread_mutex_lock(&mBiDictMutex);
+ uint32_t ret = mTypeMap[session];
+ pthread_mutex_unlock(&mBiDictMutex);
+ return ret;
+ }
+ std::vector<uint32_t> getAllSessions() {
+ std::vector<uint32_t> ret;
+ pthread_mutex_lock(&mBiDictMutex);
+ for (auto it = mBackwardMap.begin(); it != mBackwardMap.end(); it++) {
+ ret.push_back(it->first);
+ }
+ pthread_mutex_unlock(&mBiDictMutex);
+ return ret;
+ }
+ private:
+ pthread_mutex_t mBiDictMutex;
+ // mForwarMap mapping id->session
+ std::map<uint32_t, uint32_t> mForwardMap;
+ // mBackwardMap mapping session->id
+ std::map<uint32_t, uint32_t> mBackwardMap;
+ // mTypeMap mapping session->type
+ std::map<uint32_t, uint32_t> mTypeMap;
+ };
+
+ class LocationAPIRequest {
+ public:
+ LocationAPIRequest(LocationAPIClientBase& API) : mAPI(API) {}
+ virtual ~LocationAPIRequest() {}
+ virtual void onResponse(LocationError /*error*/) {};
+ virtual void onCollectiveResponse(
+ size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {};
+ LocationAPIClientBase& mAPI;
+ };
+
+ class StartTrackingRequest : public LocationAPIRequest {
+ public:
+ StartTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onStartTrackingCb(error);
+ }
+ };
+
+ class StopTrackingRequest : public LocationAPIRequest {
+ public:
+ StopTrackingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onStopTrackingCb(error);
+ }
+ };
+
+ class UpdateTrackingOptionsRequest : public LocationAPIRequest {
+ public:
+ UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onUpdateTrackingOptionsCb(error);
+ }
+ };
+
+ class StartBatchingRequest : public LocationAPIRequest {
+ public:
+ StartBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onStartBatchingCb(error);
+ }
+ };
+
+ class StopBatchingRequest : public LocationAPIRequest {
+ public:
+ StopBatchingRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onStopBatchingCb(error);
+ }
+ };
+
+ class UpdateBatchingOptionsRequest : public LocationAPIRequest {
+ public:
+ UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onUpdateBatchingOptionsCb(error);
+ }
+ };
+
+ class GetBatchedLocationsRequest : public LocationAPIRequest {
+ public:
+ GetBatchedLocationsRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onGetBatchedLocationsCb(error);
+ }
+ };
+
+ class AddGeofencesRequest : public LocationAPIRequest {
+ public:
+ AddGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
+ uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
+ for (size_t i = 0; i < count; i++) {
+ ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
+ }
+ mAPI.onAddGeofencesCb(count, errors, ids);
+ free(ids);
+ }
+ };
+
+ class RemoveGeofencesRequest : public LocationAPIRequest {
+ public:
+ RemoveGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
+ uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
+ for (size_t i = 0; i < count; i++) {
+ ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
+ mAPI.mGeofenceBiDict.rmBySession(sessions[i]);
+ }
+ mAPI.onRemoveGeofencesCb(count, errors, ids);
+ free(ids);
+ }
+ };
+
+ class ModifyGeofencesRequest : public LocationAPIRequest {
+ public:
+ ModifyGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
+ uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
+ for (size_t i = 0; i < count; i++) {
+ ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
+ }
+ mAPI.onModifyGeofencesCb(count, errors, ids);
+ free(ids);
+ }
+ };
+
+ class PauseGeofencesRequest : public LocationAPIRequest {
+ public:
+ PauseGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
+ uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
+ for (size_t i = 0; i < count; i++) {
+ ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
+ }
+ mAPI.onPauseGeofencesCb(count, errors, ids);
+ free(ids);
+ }
+ };
+
+ class ResumeGeofencesRequest : public LocationAPIRequest {
+ public:
+ ResumeGeofencesRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
+ uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
+ for (size_t i = 0; i < count; i++) {
+ ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
+ }
+ mAPI.onResumeGeofencesCb(count, errors, ids);
+ free(ids);
+ }
+ };
+
+ class GnssNiResponseRequest : public LocationAPIRequest {
+ public:
+ GnssNiResponseRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onGnssNiResponseCb(error);
+ }
+ };
+
+ class GnssDeleteAidingDataRequest : public LocationAPIRequest {
+ public:
+ GnssDeleteAidingDataRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onGnssDeleteAidingDataCb(error);
+ }
+ };
+
+ class EnableRequest : public LocationAPIRequest {
+ public:
+ EnableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onEnableCb(error);
+ }
+ };
+
+ class DisableRequest : public LocationAPIRequest {
+ public:
+ DisableRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onResponse(LocationError error) {
+ mAPI.onDisableCb(error);
+ }
+ };
+
+ class GnssUpdateConfigRequest : public LocationAPIRequest {
+ public:
+ GnssUpdateConfigRequest(LocationAPIClientBase& API) : LocationAPIRequest(API) {}
+ inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
+ mAPI.onGnssUpdateConfigCb(count, errors, ids);
+ }
+ };
+
+ class RequestQueue {
+ public:
+ RequestQueue(uint32_t session): mSession(session) {
+ }
+ ~RequestQueue() {
+ LocationAPIRequest* request = nullptr;
+ while (!mQueue.empty()) {
+ request = mQueue.front();
+ mQueue.pop();
+ delete request;
+ }
+ }
+ void push(LocationAPIRequest* request) {
+ mQueue.push(request);
+ }
+ LocationAPIRequest* pop() {
+ LocationAPIRequest* request = nullptr;
+ if (!mQueue.empty()) {
+ request = mQueue.front();
+ mQueue.pop();
+ }
+ return request;
+ }
+ uint32_t getSession() { return mSession; }
+ private:
+ uint32_t mSession;
+ std::queue<LocationAPIRequest*> mQueue;
+ };
+
+ LocationAPIRequest* getRequestBySession(uint32_t session);
+ LocationAPIRequest* getGeofencesRequest();
+
+private:
+ pthread_mutex_t mMutex;
+
+ trackingCallback mTrackingCallback;
+ batchingCallback mBatchingCallback;
+ geofenceBreachCallback mGeofenceBreachCallback;
+
+ LocationAPI* mLocationAPI;
+ LocationControlAPI* mLocationControlAPI;
+
+ BiDict mGeofenceBiDict;
+ RequestQueue* mRequestQueues[REQUEST_MAX];
+ std::map<uint32_t, SessionEntity> mSessionMap;
+ int32_t mBatchSize;
+
+ GnssConfig mConfig;
+};
+
+#endif /* LOCATION_API_CLINET_BASE_H */
diff --git a/msm8998/location/location_interface.h b/msm8998/location/location_interface.h
new file mode 100644
index 0000000..b084b65
--- /dev/null
+++ b/msm8998/location/location_interface.h
@@ -0,0 +1,90 @@
+/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LOCATION_INTERFACE_H
+#define LOCATION_INTERFACE_H
+
+#include <LocationAPI.h>
+
+struct GnssInterface {
+ size_t size;
+ void (*initialize)(void);
+ void (*deinitialize)(void);
+ void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
+ void (*removeClient)(LocationAPI* client);
+ void (*requestCapabilities)(LocationAPI* client);
+ uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
+ void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
+ void (*stopTracking)(LocationAPI* client, uint32_t id);
+ void (*gnssNiResponse)(LocationAPI* client, uint32_t id, GnssNiResponse response);
+ void (*setControlCallbacks)(LocationControlCallbacks& controlCallbacks);
+ uint32_t (*enable)(LocationTechnologyType techType);
+ void (*disable)(uint32_t id);
+ uint32_t* (*gnssUpdateConfig)(GnssConfig config);
+ uint32_t (*gnssDeleteAidingData)(GnssAidingData& data);
+ void (*injectLocation)(double latitude, double longitude, float accuracy);
+ void (*injectTime)(int64_t time, int64_t timeReference, int32_t uncertainty);
+ void (*agpsInit)(void* statusV4Cb);
+ void (*agpsDataConnOpen)(short agpsType, const char* apnName, int apnLen, int ipType);
+ void (*agpsDataConnClosed)(short agpsType);
+ void (*agpsDataConnFailed)(short agpsType);
+};
+
+struct FlpInterface {
+ size_t size;
+ void (*initialize)(void);
+ void (*deinitialize)(void);
+ void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
+ void (*removeClient)(LocationAPI* client);
+ void (*requestCapabilities)(LocationAPI* client);
+ uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
+ void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
+ void (*stopTracking)(LocationAPI* client, uint32_t id);
+ uint32_t (*startBatching)(LocationAPI* client, LocationOptions&);
+ void (*stopBatching)(LocationAPI* client, uint32_t id);
+ void (*updateBatchingOptions)(LocationAPI* client, uint32_t id, LocationOptions&);
+ void (*getBatchedLocations)(LocationAPI* client, uint32_t id, size_t count);
+ void (*getPowerStateChanges)(void* powerStateCb);
+};
+
+struct GeofenceInterface {
+ size_t size;
+ void (*initialize)(void);
+ void (*deinitialize)(void);
+ void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
+ void (*removeClient)(LocationAPI* client);
+ void (*requestCapabilities)(LocationAPI* client);
+ uint32_t* (*addGeofences)(LocationAPI* client, size_t count, GeofenceOption*, GeofenceInfo*);
+ void (*removeGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
+ void (*modifyGeofences)(LocationAPI* client, size_t count, uint32_t* ids,
+ GeofenceOption* options);
+ void (*pauseGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
+ void (*resumeGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
+};
+
+#endif /* LOCATION_INTERFACE_H */
diff --git a/msm8998/utils/Makefile.am b/msm8998/utils/Makefile.am
index b121dc8..f816565 100644
--- a/msm8998/utils/Makefile.am
+++ b/msm8998/utils/Makefile.am
@@ -41,11 +41,11 @@
if USE_GLIB
libgps_utils_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libgps_utils_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libgps_utils_so_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libgps_utils_so_la_CFLAGS = $(AM_CFLAGS)
-libgps_utils_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
+libgps_utils_so_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
libgps_utils_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
diff --git a/msm8998/utils/MsgTask.cpp b/msm8998/utils/MsgTask.cpp
index f190289..f7450b9 100644
--- a/msm8998/utils/MsgTask.cpp
+++ b/msm8998/utils/MsgTask.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013,2015 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2013, 2015, 2017The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -73,11 +73,7 @@
}
void MsgTask::sendMsg(const LocMsg* msg) const {
- if (msg) {
- msg_q_snd((void*)mQ, (void*)msg, LocMsgDestroy);
- } else {
- LOC_LOGe("msg is NULL");
- }
+ msg_q_snd((void*)mQ, (void*)msg, LocMsgDestroy);
}
void MsgTask::prerun() {
@@ -86,7 +82,7 @@
}
bool MsgTask::run() {
- LOC_LOGV("MsgTask::loop() listening ...\n");
+ //LOC_LOGV("MsgTask::loop() listening ...\n");
LocMsg* msg;
msq_q_err_type result = msg_q_rcv((void*)mQ, (void **)&msg);
if (eMSG_Q_SUCCESS != result) {
diff --git a/msm8998/utils/linked_list.c b/msm8998/utils/linked_list.c
index acec5b1..2c2e686 100644
--- a/msm8998/utils/linked_list.c
+++ b/msm8998/utils/linked_list.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011, 2014, 2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -108,7 +108,7 @@
===========================================================================*/
linked_list_err_type linked_list_add(void* list_data, void *data_obj, void (*dealloc)(void*))
{
- LOC_LOGV("%s: Adding to list data_obj = 0x%08X\n", __FUNCTION__, data_obj);
+ //LOC_LOGV("%s: Adding to list data_obj = 0x%08X\n", __FUNCTION__, data_obj);
if( list_data == NULL )
{
LOC_LOGE("%s: Invalid list parameter!\n", __FUNCTION__);
@@ -160,7 +160,7 @@
===========================================================================*/
linked_list_err_type linked_list_remove(void* list_data, void **data_obj)
{
- LOC_LOGV("%s: Removing from list\n", __FUNCTION__);
+ //LOC_LOGV("%s: Removing from list\n", __FUNCTION__);
if( list_data == NULL )
{
LOC_LOGE("%s: Invalid list parameter!\n", __FUNCTION__);
@@ -267,7 +267,7 @@
bool (*equal)(void* data_0, void* data),
void* data_0, bool rm_if_found)
{
- LOC_LOGV("%s: Search the list\n", __FUNCTION__);
+ //LOC_LOGV("%s: Search the list\n", __FUNCTION__);
if( list_data == NULL || NULL == equal )
{
LOC_LOGE("%s: Invalid list parameter! list_data %p equal %p\n",
diff --git a/msm8998/utils/loc_target.cpp b/msm8998/utils/loc_target.cpp
index 7e475eb..1016861 100644
--- a/msm8998/utils/loc_target.cpp
+++ b/msm8998/utils/loc_target.cpp
@@ -52,9 +52,6 @@
#define STR_SURF "Surf"
#define STR_MTP "MTP"
#define STR_APQ "apq"
-#define STR_SDC "sdc" // alternative string for APQ targets
-#define STR_MSM "msm"
-#define STR_SDM "sdm" // alternative string for MSM targets
#define STR_APQ_NO_WGR "baseband_apq_nowgr"
#define STR_AUTO "auto"
#define IS_STR_END(c) ((c) == '\0' || (c) == '\n' || (c) == '\r')
@@ -201,7 +198,7 @@
static const char hw_platform_dep[] =
"/sys/devices/system/soc/soc0/hw_platform";
static const char id_dep[] = "/sys/devices/system/soc/soc0/id";
- static const char mdm[] = "/target"; // mdm target we are using
+ static const char mdm[] = "/dev/mdm"; // No such file or directory
char rd_hw_platform[LINE_LEN];
char rd_id[LINE_LEN];
@@ -241,8 +238,7 @@
goto detected;
}
- if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ||
- !memcmp(baseband, STR_SDC, LENGTH(STR_SDC)) ){
+ if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){
if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1))
&& IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) )
@@ -261,17 +257,11 @@
if (!read_a_line( mdm, rd_mdm, LINE_LEN))
gTarget = TARGET_MDM;
}
-
else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1))
&& IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) ||
(!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2))
&& IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) )
gTarget = TARGET_MSM_NO_SSC;
-
- else if ( !memcmp(baseband, STR_MSM, LENGTH(STR_MSM)) ||
- !memcmp(baseband, STR_SDM, LENGTH(STR_SDM)) )
- gTarget = TARGET_DEFAULT;
-
else
gTarget = TARGET_UNKNOWN;
}
diff --git a/msm8998/utils/msg_q.c b/msm8998/utils/msg_q.c
index e412e78..7e0ac2c 100644
--- a/msm8998/utils/msg_q.c
+++ b/msm8998/utils/msg_q.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2012, 2014, 2017 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
@@ -198,7 +198,7 @@
msg_q* p_msg_q = (msg_q*)msg_q_data;
pthread_mutex_lock(&p_msg_q->list_mutex);
- LOC_LOGV("%s: Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj);
+ //LOC_LOGV("%s: Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj);
if( p_msg_q->unblocked )
{
@@ -214,7 +214,7 @@
pthread_mutex_unlock(&p_msg_q->list_mutex);
- LOC_LOGV("%s: Finished Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj);
+ //LOC_LOGV("%s: Finished Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj);
return rv;
}
@@ -241,7 +241,7 @@
msg_q* p_msg_q = (msg_q*)msg_q_data;
- LOC_LOGV("%s: Waiting on message\n", __FUNCTION__);
+ //LOC_LOGV("%s: Waiting on message\n", __FUNCTION__);
pthread_mutex_lock(&p_msg_q->list_mutex);
@@ -262,7 +262,7 @@
pthread_mutex_unlock(&p_msg_q->list_mutex);
- LOC_LOGV("%s: Received message 0x%08X rv = %d\n", __FUNCTION__, *msg_obj, rv);
+ //LOC_LOGV("%s: Received message 0x%08X rv = %d\n", __FUNCTION__, *msg_obj, rv);
return rv;
}
diff --git a/msm8998/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h b/msm8998/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h
index d0795eb..c712122 100644
--- a/msm8998/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h
+++ b/msm8998/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h
@@ -66,18 +66,6 @@
#endif /* USE_GLIB */
-
-// Below are the location conf file paths
-extern const char LOC_PATH_GPS_CONF[];
-extern const char LOC_PATH_IZAT_CONF[];
-extern const char LOC_PATH_FLP_CONF[];
-extern const char LOC_PATH_LOWI_CONF[];
-extern const char LOC_PATH_SAP_CONF[];
-extern const char LOC_PATH_APDR_CONF[];
-extern const char LOC_PATH_XTWIFI_CONF[];
-extern const char LOC_PATH_QUIPC_CONF[];
-
-
#ifdef __cplusplus
}
#endif /*__cplusplus */
diff --git a/msm8998/utils/platform_lib_abstractions/loc_pla/src/Makefile.am b/msm8998/utils/platform_lib_abstractions/loc_pla/src/Makefile.am
index d82aa55..6ee0be7 100644
--- a/msm8998/utils/platform_lib_abstractions/loc_pla/src/Makefile.am
+++ b/msm8998/utils/platform_lib_abstractions/loc_pla/src/Makefile.am
@@ -27,11 +27,11 @@
if USE_GLIB
libloc_pla_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_pla_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_pla_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_pla_la_CFLAGS = $(AM_CFLAGS)
-libloc_pla_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
+libloc_pla_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
libloc_pla_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
diff --git a/msm8998/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp b/msm8998/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp
index 3cb51a3..ef23201 100644
--- a/msm8998/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp
+++ b/msm8998/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp
@@ -26,7 +26,6 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "platform_lib_log_util.h"
-#include "platform_lib_macros.h"
char * get_timestamp(char *str, unsigned long buf_size)
{
@@ -41,38 +40,3 @@
return str;
}
-// Below are the location conf file paths
-#ifdef __ANDROID__
-
-#define LOC_PATH_GPS_CONF_STR "/vendor/etc/gps.conf"
-#define LOC_PATH_IZAT_CONF_STR "/vendor/etc/izat.conf"
-#define LOC_PATH_FLP_CONF_STR "/vendor/etc/flp.conf"
-#define LOC_PATH_LOWI_CONF_STR "/vendor/etc/lowi.conf"
-#define LOC_PATH_SAP_CONF_STR "/vendor/etc/sap.conf"
-#define LOC_PATH_APDR_CONF_STR "/vendor/etc/apdr.conf"
-#define LOC_PATH_XTWIFI_CONF_STR "/vendor/etc/xtwifi.conf"
-#define LOC_PATH_QUIPC_CONF_STR "/vendor/etc/quipc.conf"
-
-#else
-
-#define LOC_PATH_GPS_CONF_STR "/etc/gps.conf"
-#define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf"
-#define LOC_PATH_FLP_CONF_STR "/etc/flp.conf"
-#define LOC_PATH_LOWI_CONF_STR "/etc/lowi.conf"
-#define LOC_PATH_SAP_CONF_STR "/etc/sap.conf"
-#define LOC_PATH_APDR_CONF_STR "/etc/apdr.conf"
-#define LOC_PATH_XTWIFI_CONF_STR "/etc/xtwifi.conf"
-#define LOC_PATH_QUIPC_CONF_STR "/etc/quipc.conf"
-
-#endif // __ANDROID__
-
-// Reference below arrays wherever needed to avoid duplicating
-// same conf path string over and again in location code.
-const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR;
-const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR;
-const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR;
-const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR;
-const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR;
-const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR;
-const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR;
-const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR;
diff --git a/msm8998/utils/platform_lib_abstractions/loc_stub/src/Makefile.am b/msm8998/utils/platform_lib_abstractions/loc_stub/src/Makefile.am
index ba823a2..8bda711 100644
--- a/msm8998/utils/platform_lib_abstractions/loc_stub/src/Makefile.am
+++ b/msm8998/utils/platform_lib_abstractions/loc_stub/src/Makefile.am
@@ -26,11 +26,11 @@
if USE_GLIB
libloc_stub_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-libloc_stub_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_stub_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
else
libloc_stub_la_CFLAGS = $(AM_CFLAGS)
-libloc_stub_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
+libloc_stub_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
libloc_stub_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
endif
