From 70112e298fdbfe89251e0823ef05c6bc6f92c0ec Mon Sep 17 00:00:00 2001 From: Boram Bae Date: Tue, 29 Jun 2021 15:26:28 +0900 Subject: [PATCH] Update based on review * Change a long lambda to local function to improve readability * Apply naming convention * Use enum class instead of enum * Use constexpr rather than macro Signed-off-by: Boram Bae --- .../src/permission_handler_tizen_plugin.cc | 49 ++- .../tizen/src/permission_manager.cc | 389 +++++++++--------- .../tizen/src/permission_manager.h | 22 +- .../tizen/src/service_manager.cc | 14 +- .../tizen/src/service_manager.h | 7 +- packages/permission_handler/tizen/src/type.h | 68 ++- 6 files changed, 284 insertions(+), 265 deletions(-) diff --git a/packages/permission_handler/tizen/src/permission_handler_tizen_plugin.cc b/packages/permission_handler/tizen/src/permission_handler_tizen_plugin.cc index 07c22e023..867e5daef 100644 --- a/packages/permission_handler/tizen/src/permission_handler_tizen_plugin.cc +++ b/packages/permission_handler/tizen/src/permission_handler_tizen_plugin.cc @@ -9,15 +9,17 @@ #include "permission_manager.h" #include "service_manager.h" -#define PERMISSION_HANDLER_CHANNEL_NAME \ - "flutter.baseflow.com/permissions/methods" +namespace { +constexpr char kPermissionHandlerChannelName[] = + "flutter.baseflow.com/permissions/methods"; +} class PermissionHandlerTizenPlugin : public flutter::Plugin { public: static void RegisterWithRegistrar(flutter::PluginRegistrar *registrar) { auto channel = std::make_unique>( - registrar->messenger(), PERMISSION_HANDLER_CHANNEL_NAME, + registrar->messenger(), kPermissionHandlerChannelName, &flutter::StandardMethodCodec::GetInstance()); auto plugin = std::make_unique(); @@ -46,8 +48,8 @@ class PermissionHandlerTizenPlugin : public flutter::Plugin { if (std::holds_alternative(*arguments)) { int permission = std::get(*arguments); auto reply = result.release(); - auto on_success = [reply](int status) { - reply->Success(flutter::EncodableValue(status)); + auto on_success = [reply](ServiceStatus status) { + reply->Success(flutter::EncodableValue(static_cast(status))); delete reply; }; auto on_error = [reply](const std::string &code, @@ -55,7 +57,8 @@ class PermissionHandlerTizenPlugin : public flutter::Plugin { reply->Error(code, message); delete reply; }; - service_manager_.CheckServiceStatus(permission, on_success, on_error); + service_manager_.CheckServiceStatus( + static_cast(permission), on_success, on_error); } else { result->Error("MethodCall - Invalid arguments", "arguments type of method checkServiceStatus isn't int"); @@ -65,8 +68,8 @@ class PermissionHandlerTizenPlugin : public flutter::Plugin { if (std::holds_alternative(*arguments)) { int permission = std::get(*arguments); auto reply = result.release(); - auto on_success = [reply](int status) { - reply->Success(flutter::EncodableValue(status)); + auto on_success = [reply](PermissionStatus status) { + reply->Success(flutter::EncodableValue(static_cast(status))); delete reply; }; auto on_error = [reply](const std::string &code, @@ -74,8 +77,8 @@ class PermissionHandlerTizenPlugin : public flutter::Plugin { reply->Error(code, message); delete reply; }; - permission_manager_.CheckPermissionStatus(permission, on_success, - on_error); + permission_manager_.CheckPermissionStatus( + static_cast(permission), on_success, on_error); } else { result->Error( "MethodCall - Invalid arguments", @@ -84,20 +87,24 @@ class PermissionHandlerTizenPlugin : public flutter::Plugin { } else if (method_name.compare("requestPermissions") == 0) { const flutter::EncodableValue *arguments = method_call.arguments(); if (std::holds_alternative(*arguments)) { - std::vector permissions; + std::vector permissions; for (auto iter : std::get(*arguments)) { - permissions.push_back(std::get(iter)); + permissions.push_back( + static_cast(std::get(iter))); } auto reply = result.release(); - auto on_success = [reply](const std::map &results) { - flutter::EncodableMap encodables; - for (auto [key, value] : results) { - encodables.emplace(flutter::EncodableValue(key), - flutter::EncodableValue(value)); - } - reply->Success(flutter::EncodableValue(encodables)); - delete reply; - }; + auto on_success = + [reply]( + const std::map &results) { + flutter::EncodableMap encodables; + for (auto [key, value] : results) { + encodables.emplace( + flutter::EncodableValue(static_cast(key)), + flutter::EncodableValue(static_cast(value))); + } + reply->Success(flutter::EncodableValue(encodables)); + delete reply; + }; auto on_error = [reply](const std::string &code, const std::string &message) { reply->Error(code, message); diff --git a/packages/permission_handler/tizen/src/permission_manager.cc b/packages/permission_handler/tizen/src/permission_manager.cc index ddfd08f4f..6068f1966 100644 --- a/packages/permission_handler/tizen/src/permission_manager.cc +++ b/packages/permission_handler/tizen/src/permission_manager.cc @@ -5,28 +5,39 @@ #include "log.h" #include "type.h" -const char* PRIVILEGE_CALENDAR_READ = +namespace { + +constexpr char kPrivilegeCalendarRead[] = "http://tizen.org/privilege/calendar.read"; -const char* PRIVILEGE_CALENDAR_WRITE = +constexpr char kPrivilegeCalendarWrite[] = "http://tizen.org/privilege/calendar.write"; -const char* PRIVILEGE_CAMERA = "http://tizen.org/privilege/camera"; -const char* PRIVILEGE_CONTACT_READ = "http://tizen.org/privilege/contact.read"; -const char* PRIVILEGE_CONTACT_WRITE = +constexpr char kPrivilegeCamera[] = "http://tizen.org/privilege/camera"; +constexpr char kPrivilegeContactRead[] = + "http://tizen.org/privilege/contact.read"; +constexpr char kPrivilegeContactWrite[] = "http://tizen.org/privilege/contact.write"; -const char* PRIVILEGE_LOCATION = "http://tizen.org/privilege/location"; -const char* PRIVILEGE_LOCATION_COARSE = +constexpr char kPrivilegeLocation[] = "http://tizen.org/privilege/location"; +constexpr char kPrivilegeLocationCoarse[] = "http://tizen.org/privilege/location.coarse"; -const char* PRIVILEGE_RECORDER = "http://tizen.org/privilege/recorder"; -const char* PRIVILEGE_CALL = "http://tizen.org/privilege/call"; -const char* PRIVILEGE_SENSORS = "http://tizen.org/privilege/healthinfo"; -const char* PRIVILEGE_MESSAGE_READ = "http://tizen.org/privilege/message.read"; -const char* PRIVILEGE_MESSAGE_WRITE = +constexpr char kPrivilegeRecorder[] = "http://tizen.org/privilege/recorder"; +constexpr char kPrivilegeCall[] = "http://tizen.org/privilege/call"; +constexpr char kPrivilegeSensors[] = "http://tizen.org/privilege/healthinfo"; +constexpr char kPrivilegeMessageRead[] = + "http://tizen.org/privilege/message.read"; +constexpr char kPrivilegeMessageWrite[] = "http://tizen.org/privilege/message.write"; -const char* PRIVILEGE_EXTERNAL_STORAGE = +constexpr char kPrivilegeExternalStorage[] = "http://tizen.org/privilege/externalstorage"; -const char* PRIVILEGE_MEDIA_STORAGE = "http://tizen.org/privilege/mediastorage"; +constexpr char kPrivilegeMediaStorage[] = + "http://tizen.org/privilege/mediastorage"; + +struct Param { + PermissionManager* manager{nullptr}; + bool is_done{false}; + size_t remaining_request{0}; +}; -static std::string CheckResultToString(int result) { +std::string CheckResultToString(int result) { switch (result) { case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW: return "CHECK_RESULT_ALLOW"; @@ -39,7 +50,7 @@ static std::string CheckResultToString(int result) { } } -static std::string RequestResultToString(int result) { +std::string RequestResultToString(int result) { switch (result) { case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_ALLOW_FOREVER: return "REQUEST_RESULT_ALLOW_FOREVER"; @@ -52,16 +63,177 @@ static std::string RequestResultToString(int result) { } } +bool ConvertToPermission(const std::string& privilege, + PermissionGroup* permission) { + if (privilege == kPrivilegeCalendarRead || + privilege == kPrivilegeCalendarWrite) { + *permission = PermissionGroup::kCalendar; + } else if (privilege == kPrivilegeCamera) { + *permission = PermissionGroup::kCamera; + } else if (privilege == kPrivilegeContactRead || + privilege == kPrivilegeContactWrite) { + *permission = PermissionGroup::kContacts; + } else if (privilege == kPrivilegeLocation || + privilege == kPrivilegeLocationCoarse) { + *permission = PermissionGroup::kLocation; + } else if (privilege == kPrivilegeRecorder) { + *permission = PermissionGroup::kMicrophone; + } else if (privilege == kPrivilegeCall) { + *permission = PermissionGroup::kPhone; + } else if (privilege == kPrivilegeSensors) { + *permission = PermissionGroup::kSensors; + } else if (privilege == kPrivilegeMessageRead || + privilege == kPrivilegeMessageWrite) { + *permission = PermissionGroup::kSMS; + } else if (privilege == kPrivilegeExternalStorage) { + *permission = PermissionGroup::kStorage; + } else if (privilege == kPrivilegeMediaStorage) { + *permission = PermissionGroup::kMediaLibrary; + } else { + LOG_WARN("Unknown Privilege!"); + return false; + } + return true; +} + +bool ConvertToPrivileges(PermissionGroup permission, + std::vector* privileges) { + switch (permission) { + case PermissionGroup::kCalendar: + privileges->push_back(kPrivilegeCalendarRead); + privileges->push_back(kPrivilegeCalendarWrite); + break; + case PermissionGroup::kCamera: + privileges->push_back(kPrivilegeCamera); + break; + case PermissionGroup::kContacts: + privileges->push_back(kPrivilegeContactRead); + privileges->push_back(kPrivilegeContactWrite); + break; + case PermissionGroup::kLocation: + case PermissionGroup::kLocatoinAlways: + case PermissionGroup::kLocatoinWhenInUse: + privileges->push_back(kPrivilegeLocation); + privileges->push_back(kPrivilegeLocationCoarse); + break; + case PermissionGroup::kMicrophone: + privileges->push_back(kPrivilegeRecorder); + break; + case PermissionGroup::kPhone: + privileges->push_back(kPrivilegeCall); + break; + case PermissionGroup::kSensors: + privileges->push_back(kPrivilegeSensors); + break; + case PermissionGroup::kSMS: + privileges->push_back(kPrivilegeMessageRead); + privileges->push_back(kPrivilegeMessageWrite); + break; + case PermissionGroup::kStorage: + privileges->push_back(kPrivilegeExternalStorage); + break; + case PermissionGroup::kMediaLibrary: + privileges->push_back(kPrivilegeMediaStorage); + break; + default: + LOG_WARN("Unknown Permission!"); + return false; + } + return true; +} + +int DeterminePermissionStatus(PermissionGroup permission, + PermissionStatus* status) { + std::vector privileges; + ConvertToPrivileges(permission, &privileges); + + if (privileges.size() == 0) { + LOG_DEBUG("No tizen specific privileges needed for permission %d", + permission); + *status = PermissionStatus::kGranted; + return PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE; + } + + int result; + ppm_check_result_e check_result; + for (auto iter : privileges) { + result = ppm_check_permission(iter, &check_result); + if (result != PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE) { + LOG_ERROR("ppm_check_permission (%s) error: %s", iter, + get_error_message(result)); + return result; + } else { + LOG_DEBUG("ppm_check_permission (%s) result: %s", iter, + CheckResultToString(check_result).c_str()); + switch (check_result) { + case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_DENY: + case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ASK: + *status = PermissionStatus::kDenied; + return result; + case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW: + default: + *status = PermissionStatus::kGranted; + break; + } + } + } + return result; +} + +void OnRequestPermissionsRespon(ppm_call_cause_e cause, + ppm_request_result_e result, + const char* privilege, void* data) { + Param* param = (Param*)data; + PermissionManager* manager = param->manager; + PermissionGroup permission; + + if (cause != PRIVACY_PRIVILEGE_MANAGER_CALL_CAUSE_ANSWER || + !ConvertToPermission(privilege, &permission)) { + // abandon a request + LOG_ERROR("Privilege[%s] request failed with an error", privilege); + param->is_done = true; + return; + } + + if (manager->RequestResults().count(permission) == 0) { + switch (result) { + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_ALLOW_FOREVER: + manager->RequestResults()[permission] = PermissionStatus::kGranted; + break; + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_ONCE: + manager->RequestResults()[permission] = PermissionStatus::kDenied; + break; + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_FOREVER: + manager->RequestResults()[permission] = + PermissionStatus::kNeverAskAgain; + break; + } + } + LOG_DEBUG("permission %d status: %d", permission, + manager->RequestResults()[permission]); + auto location = manager->RequestResults().find(PermissionGroup::kLocation); + if (location != manager->RequestResults().end()) { + manager->RequestResults()[PermissionGroup::kLocatoinAlways] = + location->second; + manager->RequestResults()[PermissionGroup::kLocatoinWhenInUse] = + location->second; + } + + param->remaining_request--; + param->is_done = true; +} +} // namespace + PermissionManager::PermissionManager() : on_going_(false) {} PermissionManager::~PermissionManager() {} void PermissionManager::CheckPermissionStatus( - int permission, OnPermissionChecked success_callback, + PermissionGroup permission, OnPermissionChecked success_callback, OnPermissionError error_callback) { LOG_DEBUG("Check permission %d status", permission); - int status; + PermissionStatus status; int result = DeterminePermissionStatus(permission, &status); if (result != PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE) { error_callback(get_error_message(result), @@ -72,15 +244,15 @@ void PermissionManager::CheckPermissionStatus( } void PermissionManager::RequestPermissions( - std::vector permissions, OnPermissionRequested success_callback, - OnPermissionError error_callback) { + std::vector permissions, + OnPermissionRequested success_callback, OnPermissionError error_callback) { if (on_going_) { error_callback("RequestPermissions - error", "A request for permissions is already running"); return; } - - int status, result; + int result; + PermissionStatus status; request_results_.clear(); std::vector permissions_to_request; for (auto permission : permissions) { @@ -91,16 +263,15 @@ void PermissionManager::RequestPermissions( return; } - if (status == PERMISSION_STATUS_GRANTED) { + if (status == PermissionStatus::kGranted) { if (request_results_.find(permission) == request_results_.end()) { - LOG_DEBUG("Request permission %d result: PERMISSION_STATUS_GRANTED", - permission); - request_results_[permission] = PERMISSION_STATUS_GRANTED; + LOG_DEBUG("Request permission %d result: kGranted", permission); + request_results_[permission] = PermissionStatus::kGranted; } continue; } - ConvertToPrivileges(permission, permissions_to_request); + ConvertToPrivileges(permission, &permissions_to_request); } // no permission is needed to requested @@ -111,63 +282,14 @@ void PermissionManager::RequestPermissions( on_going_ = true; - struct Param { - PermissionManager* self{nullptr}; - bool is_done{false}; - size_t remaining_request{0}; - }; Param p; - p.self = this; + p.manager = this; p.remaining_request = permissions_to_request.size(); for (size_t i = 0; i < permissions_to_request.size(); i++) { const char* permission = permissions_to_request[i]; p.is_done = false; - result = ppm_request_permission( - permission, - [](ppm_call_cause_e cause, ppm_request_result_e result, - const char* privilege, void* data) { - Param* param = (Param*)data; - PermissionManager* self = param->self; - - if (cause != PRIVACY_PRIVILEGE_MANAGER_CALL_CAUSE_ANSWER) { - // abandon a request - LOG_ERROR("Privilege[%s] request failed with an error", privilege); - param->is_done = true; - return; - } - - int permission = self->ConvertToPermission(privilege); - - if (self->request_results_.count(permission) == 0) { - switch (result) { - case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_ALLOW_FOREVER: - self->request_results_[permission] = PERMISSION_STATUS_GRANTED; - break; - case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_ONCE: - self->request_results_[permission] = PERMISSION_STATUS_DENIED; - break; - case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_FOREVER: - self->request_results_[permission] = - PERMISSION_STATUS_NEVER_ASK_AGAIN; - break; - } - } - LOG_DEBUG("permission %d status: %d", permission, - self->request_results_[permission]); - auto location = - self->request_results_.find(PERMISSION_GROUP_LOCATION); - if (location != self->request_results_.end()) { - self->request_results_[PERMISSION_GROUP_LOCATION_ALWAYS] = - location->second; - self->request_results_[PERMISSION_GROUP_LOCATION_WHEN_IN_USE] = - location->second; - } - - param->remaining_request--; - param->is_done = true; - }, - &p); + result = ppm_request_permission(permission, OnRequestPermissionsRespon, &p); if (result != PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE) { LOG_ERROR("Failed to call ppm_request_permission with [%s]", permission); @@ -188,114 +310,3 @@ void PermissionManager::RequestPermissions( } on_going_ = false; } - -int PermissionManager::ConvertToPermission(const std::string& privilege) { - if (privilege == PRIVILEGE_CALENDAR_READ || - privilege == PRIVILEGE_CALENDAR_WRITE) { - return PERMISSION_GROUP_CALENDAR; - } else if (privilege == PRIVILEGE_CAMERA) { - return PERMISSION_GROUP_CAMERA; - } else if (privilege == PRIVILEGE_CONTACT_READ || - privilege == PRIVILEGE_CONTACT_WRITE) { - return PERMISSION_GROUP_CONTACTS; - } else if (privilege == PRIVILEGE_LOCATION || - privilege == PRIVILEGE_LOCATION_COARSE) { - return PERMISSION_GROUP_LOCATION; - } else if (privilege == PRIVILEGE_RECORDER) { - return PERMISSION_GROUP_MICROPHONE; - } else if (privilege == PRIVILEGE_CALL) { - return PERMISSION_GROUP_PHONE; - } else if (privilege == PRIVILEGE_SENSORS) { - return PERMISSION_GROUP_SENSORS; - } else if (privilege == PRIVILEGE_MESSAGE_READ || - privilege == PRIVILEGE_MESSAGE_WRITE) { - return PERMISSION_GROUP_SMS; - } else if (privilege == PRIVILEGE_EXTERNAL_STORAGE) { - return PERMISSION_GROUP_STORAGE; - } else if (privilege == PRIVILEGE_MEDIA_STORAGE) { - return PERMISSION_GROUP_MEDIA_LIBRARY; - } else { - return PERMISSION_GROUP_UNKNOWN; - } -} - -void PermissionManager::ConvertToPrivileges( - int permission, std::vector& privileges) { - switch (permission) { - case PERMISSION_GROUP_CALENDAR: - privileges.push_back(PRIVILEGE_CALENDAR_READ); - privileges.push_back(PRIVILEGE_CALENDAR_WRITE); - break; - case PERMISSION_GROUP_CAMERA: - privileges.push_back(PRIVILEGE_CAMERA); - break; - case PERMISSION_GROUP_CONTACTS: - privileges.push_back(PRIVILEGE_CONTACT_READ); - privileges.push_back(PRIVILEGE_CONTACT_WRITE); - break; - case PERMISSION_GROUP_LOCATION: - case PERMISSION_GROUP_LOCATION_ALWAYS: - case PERMISSION_GROUP_LOCATION_WHEN_IN_USE: - privileges.push_back(PRIVILEGE_LOCATION); - privileges.push_back(PRIVILEGE_LOCATION_COARSE); - break; - case PERMISSION_GROUP_MICROPHONE: - privileges.push_back(PRIVILEGE_RECORDER); - break; - case PERMISSION_GROUP_PHONE: - privileges.push_back(PRIVILEGE_CALL); - break; - case PERMISSION_GROUP_SENSORS: - privileges.push_back(PRIVILEGE_SENSORS); - break; - case PERMISSION_GROUP_SMS: - privileges.push_back(PRIVILEGE_MESSAGE_READ); - privileges.push_back(PRIVILEGE_MESSAGE_WRITE); - break; - case PERMISSION_GROUP_STORAGE: - privileges.push_back(PRIVILEGE_EXTERNAL_STORAGE); - break; - case PERMISSION_GROUP_MEDIA_LIBRARY: - privileges.push_back(PRIVILEGE_MEDIA_STORAGE); - break; - default: - break; - } -} - -int PermissionManager::DeterminePermissionStatus(int permission, int* status) { - std::vector privileges; - ConvertToPrivileges(permission, privileges); - - if (privileges.size() == 0) { - LOG_DEBUG("No tizen specific privileges needed for permission %d", - permission); - *status = PERMISSION_STATUS_GRANTED; - return PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE; - } - - int result; - ppm_check_result_e check_result; - for (auto iter : privileges) { - result = ppm_check_permission(iter, &check_result); - if (result != PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE) { - LOG_ERROR("ppm_check_permission (%s) error: %s", iter, - get_error_message(result)); - return result; - } else { - LOG_DEBUG("ppm_check_permission (%s) result: %s", iter, - CheckResultToString(check_result).c_str()); - switch (check_result) { - case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_DENY: - case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ASK: - *status = PERMISSION_STATUS_DENIED; - return result; - case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW: - default: - *status = PERMISSION_STATUS_GRANTED; - break; - } - } - } - return result; -} diff --git a/packages/permission_handler/tizen/src/permission_manager.h b/packages/permission_handler/tizen/src/permission_manager.h index 15920f7ac..a40609e1f 100644 --- a/packages/permission_handler/tizen/src/permission_manager.h +++ b/packages/permission_handler/tizen/src/permission_manager.h @@ -8,9 +8,11 @@ #include #include -using OnPermissionChecked = std::function; -using OnPermissionRequested = - std::function &results)>; +#include "type.h" + +using OnPermissionChecked = std::function; +using OnPermissionRequested = std::function &results)>; using OnPermissionError = std::function; @@ -19,21 +21,19 @@ class PermissionManager { PermissionManager(); ~PermissionManager(); - void CheckPermissionStatus(int permission, + void CheckPermissionStatus(PermissionGroup permission, OnPermissionChecked success_callback, OnPermissionError error_callback); - void RequestPermissions(std::vector permissions, + void RequestPermissions(std::vector permissions, OnPermissionRequested success_callback, OnPermissionError error_callback); + inline std::map &RequestResults() { + return request_results_; + } private: - int ConvertToPermission(const std::string &privilege); - void ConvertToPrivileges(int permission, - std::vector &privileges); - int DeterminePermissionStatus(int permission, int *status); - bool on_going_; - std::map request_results_; + std::map request_results_; }; #endif // PERMISSION_MANAGER_H_ diff --git a/packages/permission_handler/tizen/src/service_manager.cc b/packages/permission_handler/tizen/src/service_manager.cc index 2f3c6a8db..f089ce1b5 100644 --- a/packages/permission_handler/tizen/src/service_manager.cc +++ b/packages/permission_handler/tizen/src/service_manager.cc @@ -9,12 +9,12 @@ ServiceManager::ServiceManager() {} ServiceManager::~ServiceManager() {} -void ServiceManager::CheckServiceStatus(int permission, +void ServiceManager::CheckServiceStatus(PermissionGroup permission, OnServiceChecked success_callback, OnServiceError error_callback) { - if (permission == PERMISSION_GROUP_LOCATION || - permission == PERMISSION_GROUP_LOCATION_ALWAYS || - permission == PERMISSION_GROUP_LOCATION_WHEN_IN_USE) { + if (permission == PermissionGroup::kLocation || + permission == PermissionGroup::kLocatoinAlways || + permission == PermissionGroup::kLocatoinWhenInUse) { bool gps_enabled, wps_enabled; if (location_manager_is_enabled_method( LOCATIONS_METHOD_GPS, &gps_enabled) != LOCATIONS_ERROR_NONE) { @@ -26,12 +26,12 @@ void ServiceManager::CheckServiceStatus(int permission, } if (gps_enabled || wps_enabled) { - success_callback(SERVICE_STATUS_ENABLED); + success_callback(ServiceStatus::kEnabled); } else { - success_callback(SERVICE_STATUS_DISABLED); + success_callback(ServiceStatus::kDisabled); } return; } - success_callback(SERVICE_STATUS_NOT_APPLICABLE); + success_callback(ServiceStatus::kNotApplicable); } diff --git a/packages/permission_handler/tizen/src/service_manager.h b/packages/permission_handler/tizen/src/service_manager.h index 593b90dfa..ea140cee6 100644 --- a/packages/permission_handler/tizen/src/service_manager.h +++ b/packages/permission_handler/tizen/src/service_manager.h @@ -4,7 +4,9 @@ #include #include -using OnServiceChecked = std::function; +#include "type.h" + +using OnServiceChecked = std::function; using OnServiceError = std::function; @@ -13,7 +15,8 @@ class ServiceManager { ServiceManager(); ~ServiceManager(); - void CheckServiceStatus(int permission, OnServiceChecked success_callback, + void CheckServiceStatus(PermissionGroup permission, + OnServiceChecked success_callback, OnServiceError error_callback); }; diff --git a/packages/permission_handler/tizen/src/type.h b/packages/permission_handler/tizen/src/type.h index fee96e646..1832c0dc2 100644 --- a/packages/permission_handler/tizen/src/type.h +++ b/packages/permission_handler/tizen/src/type.h @@ -1,46 +1,44 @@ #ifndef PERMISSION_HANDLER_TYPE_H_ #define PERMISSION_HANDLER_TYPE_H_ -// permission group -enum PermissionGroup { - PERMISSION_GROUP_CALENDAR = 0, - PERMISSION_GROUP_CAMERA = 1, - PERMISSION_GROUP_CONTACTS = 2, - PERMISSION_GROUP_LOCATION = 3, - PERMISSION_GROUP_LOCATION_ALWAYS = 4, - PERMISSION_GROUP_LOCATION_WHEN_IN_USE = 5, - PERMISSION_GROUP_MEDIA_LIBRARY = 6, - PERMISSION_GROUP_MICROPHONE = 7, - PERMISSION_GROUP_PHONE = 8, - PERMISSION_GROUP_PHOTOS = 9, - PERMISSION_GROUP_PHOTOS_ADD_ONLY = 10, - PERMISSION_GROUP_REMINDERS = 11, - PERMISSION_GROUP_SENSORS = 12, - PERMISSION_GROUP_SMS = 13, - PERMISSION_GROUP_SPEECH = 14, - PERMISSION_GROUP_STORAGE = 15, - PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS = 16, - PERMISSION_GROUP_NOTIFICATION = 17, - PERMISSION_GROUP_ACCESS_MEDIA_LOCATION = 18, - PERMISSION_GROUP_ACTIVITY_RECOGNITION = 19, - PERMISSION_GROUP_UNKNOWN = 20, - PERMISSION_GROUP_BLUETOOTH = 21 +// See : +// flutter-permission-handler/permission_handler_platform_interface/lib/src/permissions.dart +enum class PermissionGroup { + kCalendar = 0, + kCamera = 1, + kContacts = 2, + kLocation = 3, + kLocatoinAlways = 4, + kLocatoinWhenInUse = 5, + kMediaLibrary = 6, + kMicrophone = 7, + kPhone = 8, + kPhotos = 9, + kPhotosAddOnly = 10, + kReminders = 11, + kSensors = 12, + kSMS = 13, + kSpeech = 14, + kStorage = 15, + kIgnoreBatteryOptimizations = 16, + kNotification = 17, + kAccessMediaLocation = 18, + kActivityRecognition = 19, + kUnknown = + 20, // Define only to hold space, please never use it in native side + kBluetooth = 21 }; // permission status -enum PermissionStatus { - PERMISSION_STATUS_DENIED = 0, - PERMISSION_STATUS_GRANTED, - PERMISSION_STATUS_RESTRICTED, - PERMISSION_STATUS_LIMITED, - PERMISSION_STATUS_NEVER_ASK_AGAIN +enum class PermissionStatus { + kDenied = 0, + kGranted, + kRestricted, + kLimited, + kNeverAskAgain }; // service status -enum ServiceStatus { - SERVICE_STATUS_DISABLED = 0, - SERVICE_STATUS_ENABLED, - SERVICE_STATUS_NOT_APPLICABLE -}; +enum class ServiceStatus { kDisabled = 0, kEnabled, kNotApplicable }; #endif // PERMISSION_HANDLER_TYPE_H_