openharmony/base_location
1
0
Fork 0
mirror of https://gitee.com/openharmony/base_location synced 2024-11-23 14:59:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!892 bugfix for conditional competition

Browse Source 
Merge pull request !892 from ruan-shaofei/master
This commit is contained in:
openharmony_ci 2024-09-07 11:17:43 +00:00 committed by Gitee
commit a061a833a8
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
19 changed files with 160 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
frameworks/js/napi/include/cached_locations_callback_napi.h
View File

@ -49,8 +49,6 @@ public:
LBSLOGE(CACHED_LOCATIONS_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;

2
frameworks/js/napi/include/country_code_callback_napi.h
View File

@ -45,8 +45,6 @@ public:
LBSLOGE(COUNTRY_CODE_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;

16
frameworks/js/napi/include/gnss_status_callback_napi.h
View File

@ -28,6 +28,8 @@
namespace OHOS {
namespace Location {
bool FindGnssRegCallback(napi_ref cb);
void DeleteGnssRegCallback(napi_ref cb);
class GnssStatusCallbackNapi : public IRemoteStub<IGnssStatusCallback> {
public:
GnssStatusCallbackNapi();
@ -39,6 +41,8 @@ public:
void OnStatusChange(const std::unique_ptr<SatelliteStatus>& statusInfo) override;
void DeleteHandler();
void UvQueueWork(uv_loop_s* loop, uv_work_t* work);
napi_ref GetHandleCb();
void SetHandleCb(const napi_ref& handlerCb);
template <typename T>
bool InitContext(T* context)
@ -47,8 +51,6 @@ public:
LBSLOGE(GNSS_STATUS_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;
@ -64,16 +66,6 @@ public:
env_ = env;
}
inline napi_ref GetHandleCb() const
{
return handlerCb_;
}
inline void SetHandleCb(const napi_ref& handlerCb)
{
handlerCb_ = handlerCb;
}
inline bool GetRemoteDied() const
{
return remoteDied_;

2
frameworks/js/napi/include/locating_required_data_callback_napi.h
View File

@ -54,8 +54,6 @@ public:
LBSLOGE(LOCATING_DATA_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;

2
frameworks/js/napi/include/location_error_callback_napi.h
View File

@ -47,8 +47,6 @@ public:
LBSLOGE(LOCATION_ERR_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;

16
frameworks/js/napi/include/location_switch_callback_napi.h
View File

@ -26,6 +26,8 @@
namespace OHOS {
namespace Location {
bool FindSwitchRegCallback(napi_ref cb);
void DeleteSwitchRegCallback(napi_ref cb);
class LocationSwitchCallbackNapi : public IRemoteStub<ISwitchCallback> {
public:
LocationSwitchCallbackNapi();
@ -38,6 +40,8 @@ public:
void OnSwitchChange(int switchState) override;
void DeleteHandler();
void UvQueueWork(uv_loop_s* loop, uv_work_t* work);
napi_ref GetHandleCb();
void SetHandleCb(const napi_ref& handlerCb);
template <typename T>
bool InitContext(T* context)
@ -46,8 +50,6 @@ public:
LBSLOGE(SWITCH_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;
@ -63,16 +65,6 @@ public:
env_ = env;
}
inline napi_ref GetHandleCb() const
{
return handlerCb_;
}
inline void SetHandleCb(const napi_ref& handlerCb)
{
handlerCb_ = handlerCb;
}
inline bool GetRemoteDied() const
{
return remoteDied_;

16
frameworks/js/napi/include/locator_callback_napi.h
View File

@ -27,6 +27,8 @@
namespace OHOS {
namespace Location {
bool FindRegCallback(napi_ref cb);
void DeleteRegCallback(napi_ref cb);
class LocatorCallbackNapi : public IRemoteStub<ILocatorCallback> {
public:
LocatorCallbackNapi();
@ -52,6 +54,8 @@ public:
void Wait(int time);
int GetCount();
void SetCount(int count);
napi_ref GetHandleCb();
void SetHandleCb(const napi_ref& handlerCb);
template <typename T>
bool InitContext(T* context)
@ -66,8 +70,6 @@ public:
context->callback[FAIL_CALLBACK] = failHandlerCb_;
context->callback[COMPLETE_CALLBACK] = completeHandlerCb_;
} else {
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->callback[SUCCESS_CALLBACK] = handlerCb_;
}
return true;
@ -83,16 +85,6 @@ public:
env_ = env;
}
inline napi_ref GetHandleCb() const
{
return handlerCb_;
}
inline void SetHandleCb(const napi_ref& handlerCb)
{
handlerCb_ = handlerCb;
}
inline napi_ref GetSuccHandleCb() const
{
return successHandlerCb_;

2
frameworks/js/napi/include/nmea_message_callback_napi.h
View File

@ -49,8 +49,6 @@ public:
LBSLOGE(NMEA_MESSAGE_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;

9
frameworks/js/napi/source/cached_locations_callback_napi.cpp
View File

@ -151,11 +151,6 @@ void CachedLocationsCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -173,12 +168,8 @@ void CachedLocationsCallbackNapi::DeleteHandler()
LBSLOGE(CACHED_LOCATIONS_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

9
frameworks/js/napi/source/country_code_callback_napi.cpp
View File

@ -146,11 +146,6 @@ void CountryCodeCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -181,12 +176,8 @@ void CountryCodeCallbackNapi::DeleteHandler()
LBSLOGE(COUNTRY_CODE_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

51
frameworks/js/napi/source/gnss_status_callback_napi.cpp
View File

@ -25,6 +25,8 @@
namespace OHOS {
namespace Location {
static std::mutex g_regCallbackMutex;
static std::vector<napi_ref> g_regHandleCallbacks;
GnssStatusCallbackNapi::GnssStatusCallbackNapi()
{
env_ = nullptr;
@ -63,6 +65,39 @@ int GnssStatusCallbackNapi::OnRemoteRequest(
return 0;
}
napi_ref GnssStatusCallbackNapi::GetHandleCb()
{
return handlerCb_;
}
void GnssStatusCallbackNapi::SetHandleCb(const napi_ref& handlerCb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
handlerCb_ = handlerCb;
g_regHandleCallbacks.emplace_back(handlerCb);
}
bool FindGnssRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
auto iter = std::find(g_regHandleCallbacks.begin(), g_regHandleCallbacks.end(), cb);
if (iter == g_regHandleCallbacks.end()) {
return false;
}
return true;
}
void DeleteGnssRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
for (auto iter = g_regHandleCallbacks.begin(); iter != g_regHandleCallbacks.end(); iter++) {
if (*iter == cb) {
iter = g_regHandleCallbacks.erase(iter);
break;
}
}
}
bool GnssStatusCallbackNapi::IsRemoteDied()
{
return remoteDied_;
@ -121,6 +156,12 @@ void GnssStatusCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
delete work;
return;
}
if (!FindGnssRegCallback(context->callback[0])) {
LBSLOGE(GNSS_STATUS_CALLBACK, "no valid callback");
delete context;
delete work;
return;
}
NAPI_CALL_RETURN_VOID(context->env, napi_open_handle_scope(context->env, &scope));
if (scope == nullptr) {
LBSLOGE(GNSS_STATUS_CALLBACK, "scope is nullptr");
@ -146,11 +187,6 @@ void GnssStatusCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -168,12 +204,9 @@ void GnssStatusCallbackNapi::DeleteHandler()
LBSLOGE(GNSS_STATUS_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
DeleteGnssRegCallback(handlerCb_);
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

9
frameworks/js/napi/source/locating_required_data_callback_napi.cpp
View File

@ -170,11 +170,6 @@ void LocatingRequiredDataCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* w
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -194,13 +189,9 @@ void LocatingRequiredDataCallbackNapi::DeleteHandler()
LBSLOGE(LOCATING_DATA_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
bool LocatingRequiredDataCallbackNapi::IsSingleLocationRequest()
{

9
frameworks/js/napi/source/location_error_callback_napi.cpp
View File

@ -132,11 +132,6 @@ void LocationErrorCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -163,12 +158,8 @@ void LocationErrorCallbackNapi::DeleteHandler()
LBSLOGE(LOCATION_ERR_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

10
frameworks/js/napi/source/location_gnss_geofence_callback_napi.cpp
View File

@ -185,12 +185,6 @@ void LocationGnssGeofenceCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* w
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[SUCCESS_CALLBACK], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env,
napi_delete_reference(context->env, context->callback[SUCCESS_CALLBACK]));
}
delete context;
delete work;
});
@ -203,13 +197,9 @@ void LocationGnssGeofenceCallbackNapi::DeleteHandler()
LBSLOGE(LOCATION_GNSS_GEOFENCE_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
void LocationGnssGeofenceCallbackNapi::CountDown()
{

55
frameworks/js/napi/source/location_switch_callback_napi.cpp
View File

@ -20,6 +20,8 @@
namespace OHOS {
namespace Location {
static std::mutex g_regCallbackMutex;
static std::vector<napi_ref> g_regHandleCallbacks;
LocationSwitchCallbackNapi::LocationSwitchCallbackNapi()
{
env_ = nullptr;
@ -57,6 +59,39 @@ int LocationSwitchCallbackNapi::OnRemoteRequest(
return 0;
}
napi_ref LocationSwitchCallbackNapi::GetHandleCb()
{
return handlerCb_;
}
void LocationSwitchCallbackNapi::SetHandleCb(const napi_ref& handlerCb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
handlerCb_ = handlerCb;
g_regHandleCallbacks.emplace_back(handlerCb);
}
bool FindSwitchRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
auto iter = std::find(g_regHandleCallbacks.begin(), g_regHandleCallbacks.end(), cb);
if (iter == g_regHandleCallbacks.end()) {
return false;
}
return true;
}
void DeleteSwitchRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
for (auto iter = g_regHandleCallbacks.begin(); iter != g_regHandleCallbacks.end(); iter++) {
if (*iter == cb) {
iter = g_regHandleCallbacks.erase(iter);
break;
}
}
}
bool LocationSwitchCallbackNapi::IsRemoteDied()
{
return remoteDied_;
@ -113,12 +148,18 @@ void LocationSwitchCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
SwitchAsyncContext *context = nullptr;
napi_handle_scope scope = nullptr;
if (work == nullptr) {
LBSLOGE(LOCATOR_CALLBACK, "work is nullptr!");
LBSLOGE(SWITCH_CALLBACK, "work is nullptr!");
return;
}
context = static_cast<SwitchAsyncContext *>(work->data);
if (context == nullptr || context->env == nullptr) {
LBSLOGE(LOCATOR_CALLBACK, "context is nullptr!");
LBSLOGE(SWITCH_CALLBACK, "context is nullptr!");
delete work;
return;
}
if (!FindSwitchRegCallback(context->callback[0])) {
LBSLOGE(SWITCH_CALLBACK, "no valid callback");
delete context;
delete work;
return;
}
@ -145,11 +186,6 @@ void LocationSwitchCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -168,12 +204,9 @@ void LocationSwitchCallbackNapi::DeleteHandler()
LBSLOGE(SWITCH_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
DeleteSwitchRegCallback(handlerCb_);
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

60
frameworks/js/napi/source/locator_callback_napi.cpp
View File

@ -33,6 +33,8 @@
namespace OHOS {
namespace Location {
static std::mutex g_regCallbackMutex;
static std::vector<napi_ref> g_regHandleCallbacks;
LocatorCallbackNapi::LocatorCallbackNapi()
{
env_ = nullptr;
@ -108,6 +110,39 @@ int LocatorCallbackNapi::OnRemoteRequest(uint32_t code,
return 0;
}
napi_ref LocatorCallbackNapi::GetHandleCb()
{
return handlerCb_;
}
void LocatorCallbackNapi::SetHandleCb(const napi_ref& handlerCb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
handlerCb_ = handlerCb;
g_regHandleCallbacks.emplace_back(handlerCb);
}
bool FindRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
auto iter = std::find(g_regHandleCallbacks.begin(), g_regHandleCallbacks.end(), cb);
if (iter == g_regHandleCallbacks.end()) {
return false;
}
return true;
}
void DeleteRegCallback(napi_ref cb)
{
std::unique_lock<std::mutex> guard(g_regCallbackMutex);
for (auto iter = g_regHandleCallbacks.begin(); iter != g_regHandleCallbacks.end(); iter++) {
if (*iter == cb) {
iter = g_regHandleCallbacks.erase(iter);
break;
}
}
}
void LocatorCallbackNapi::DoSendWork(uv_loop_s*& loop, uv_work_t*& work)
{
uv_queue_work(loop, work, [](uv_work_t* work) {}, [](uv_work_t* work, int status) {
@ -125,6 +160,12 @@ void LocatorCallbackNapi::DoSendWork(uv_loop_s*& loop, uv_work_t*& work)
delete work;
return;
}
if (!FindRegCallback(context->callback[0])) {
LBSLOGE(LOCATOR_CALLBACK, "no valid callback");
delete context;
delete work;
return;
}
napi_open_handle_scope(context->env, &scope);
if (scope == nullptr) {
DELETE_SCOPE_CONTEXT_WORK(context->env, scope, context, work);
@ -149,11 +190,6 @@ void LocatorCallbackNapi::DoSendWork(uv_loop_s*& loop, uv_work_t*& work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -302,26 +338,22 @@ void LocatorCallbackNapi::DeleteHandler()
LBSLOGE(LOCATOR_CALLBACK, "env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
DeleteRegCallback(handlerCb_);
if (IsSystemGeoLocationApi()) {
napi_reference_unref(env_, successHandlerCb_, &refCount);
if (successHandlerCb_ != nullptr && refCount == 0) {
if (successHandlerCb_ != nullptr) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, successHandlerCb_));
successHandlerCb_ = nullptr;
}
napi_reference_unref(env_, failHandlerCb_, &refCount);
if (failHandlerCb_ != nullptr && refCount == 0) {
if (failHandlerCb_ != nullptr) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, failHandlerCb_));
failHandlerCb_ = nullptr;
}
napi_reference_unref(env_, completeHandlerCb_, &refCount);
if (completeHandlerCb_ != nullptr && refCount == 0) {
if (completeHandlerCb_ != nullptr) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, completeHandlerCb_));
completeHandlerCb_ = nullptr;
}
} else {
napi_reference_unref(env_, handlerCb_, &refCount);
if (handlerCb_ != nullptr && refCount == 0) {
if (handlerCb_ != nullptr) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}

9
frameworks/js/napi/source/nmea_message_callback_napi.cpp
View File

@ -153,11 +153,6 @@ void NmeaMessageCallbackNapi::UvQueueWork(uv_loop_s* loop, uv_work_t* work)
}
}
NAPI_CALL_RETURN_VOID(context->env, napi_close_handle_scope(context->env, scope));
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(context->env, context->callback[0], &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(context->env, napi_delete_reference(context->env, context->callback[0]));
}
delete context;
delete work;
});
@ -176,12 +171,8 @@ void NmeaMessageCallbackNapi::DeleteHandler()
LBSLOGE(NMEA_MESSAGE_CALLBACK, "handler or env is nullptr.");
return;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_unref(env_, handlerCb_, &refCount);
if (refCount == 0) {
NAPI_CALL_RETURN_VOID(env_, napi_delete_reference(env_, handlerCb_));
handlerCb_ = nullptr;
}
}
} // namespace Location
} // namespace OHOS

1
interfaces/inner_api/include/constant_definition.h
View File

@ -47,7 +47,6 @@ const int32_t UNKNOW_USER_ID = -1;
const int32_t SUBSCRIBE_TIME = 5;
const int32_t DEFAULT_TIME_INTERVAL = 30 * 60; // app receive location every 30 minutes in frozen state
const int32_t REQUESTS_NUM_MAX = 1;
constexpr uint32_t INVALID_REF_COUNT = 0xFF;
constexpr const char* FEATURE_SWITCH_PROP = "ro.config.locator_background";
constexpr const char* TIME_INTERVAL_PROP = "ro.config.locator_background.timeInterval";
constexpr const char* PROC_NAME = "system";

2
interfaces/inner_api/include/location_gnss_geofence_callback_napi.h
View File

@ -57,8 +57,6 @@ public:
LBSLOGE(LOCATION_GNSS_GEOFENCE_CALLBACK, "context == nullptr.");
return false;
}
uint32_t refCount = INVALID_REF_COUNT;
napi_reference_ref(env_, handlerCb_, &refCount);
context->env = env_;
context->callback[SUCCESS_CALLBACK] = handlerCb_;
return true;