Changed the passcode variable name to passkey.

Signed-off-by: segwon <segwon.han@samsung.com>
Change-Id: I71d930645fd3194b72814480a50c5a3ee2d9b62f

diff --git a/common/Types.h b/common/Types.h
index ee54c6e..9b7b44e 100644 (file)
--- a/common/Types.h
+++ b/common/Types.h
@@ -196,7 +196,7 @@ enum AccessControlState {
 #define CONV_JSON_REQUEST_TYPE                                 "request_type"
 #define CONV_JSON_ACCESS_REQUEST_TYPE                  "access_request_type"
 #define CONV_JSON_ACCESS_REQUEST_RESULT                        "access_request_result"
-#define CONV_JSON_PASSCODE                                             "passcode"
+#define CONV_JSON_PASSKEY                                              "passkey"
 #define CONV_JSON_ACCESS_CONTROL_STATE                 "access_control_state"
 #define CONV_JSON_APP_CONTROL_REPLY                            "app_control_reply"
 #define CONV_JSON_APP_CONTROL_REQUEST                  "app_control_request"
@@ -207,12 +207,12 @@ enum AccessControlState {
 #define CONV_ACCESS_CONTROL_PERMITTED                  "PERMITTED"
 #define CONV_ACCESS_CONTROL_DENIED                             "DENIED"
 
-#define CONV_ACCESS_CONTROL_PASSCODE_REQUEST   "PASSCODE_REQUEST"
-#define CONV_ACCESS_CONTROL_PASSCODE_RESPONSE  "PASSCODE_RESPONSE"
-#define CONV_ACCESS_CONTROL_PASSCODE_CANCEL            "PASSCODE_CANCEL"
-#define CONV_ACCESS_CONTROL_PASSCODE_RIGHT             "PASSCODE_RIGHT"
-#define CONV_ACCESS_CONTROL_PASSCODE_WRONG             "PASSCODE_WRONG"
-#define CONV_ACCESS_CONTROL_PASSCODE_REJECTED  "PASSCODE_REHECTED"
+#define CONV_ACCESS_CONTROL_PASSKEY_REQUEST            "PASSKEY_REQUEST"
+#define CONV_ACCESS_CONTROL_PASSKEY_RESPONSE   "PASSKEY_RESPONSE"
+#define CONV_ACCESS_CONTROL_PASSKEY_CANCEL             "PASSKEY_CANCEL"
+#define CONV_ACCESS_CONTROL_PASSKEY_RIGHT              "PASSKEY_RIGHT"
+#define CONV_ACCESS_CONTROL_PASSKEY_WRONG              "PASSKEY_WRONG"
+#define CONV_ACCESS_CONTROL_PASSKEY_REJECTED   "PASSKEY_REHECTED"
 
 #define CONV_SUBJECT_ACCESS_CONTROL_REGIST             "conv/access/regist"
 #define CONV_SUBJECT_ACCESS_CONTROL_SET                        "conv/access/set"

diff --git a/daemon/access_control/ACLManager.cpp b/daemon/access_control/ACLManager.cpp
index 04d4fa9..70bf9c6 100644 (file)
--- a/daemon/access_control/ACLManager.cpp
+++ b/daemon/access_control/ACLManager.cpp
@@ -23,9 +23,9 @@ typedef struct {
 
 usercallback_info *info = NULL;
 
-static char passcode[5];
+static char passkey[5];
 
-ACLResult conv::acl_manager::PasscodeChecker(char *input_passcode)
+ACLResult conv::acl_manager::PasskeyChecker(char *input_passkey)
 {
        bool isShowPopup = false;
        const char *app_id = "org.tizen.d2d-conv-syspopup";
@@ -39,7 +39,7 @@ ACLResult conv::acl_manager::PasscodeChecker(char *input_passcode)
        if(isShowPopup == true) {
                _D("org.tizen.d2d-conv-syspopup is running.");
 
-               if (!strcmp(passcode, input_passcode)){
+               if (!strcmp(passkey, input_passkey)){
                        _D("correct");
                        return ACLResult_OK;
 
@@ -54,7 +54,7 @@ ACLResult conv::acl_manager::PasscodeChecker(char *input_passcode)
        }
 }
 
-void CreatePasscode()
+void CreatePasskey()
 {
        char token[64] = "01234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        unsigned int time_seed = (unsigned int)time(NULL);
@@ -63,39 +63,39 @@ void CreatePasscode()
 
        for (int i = 0; i < 4; i++) {
                int random_num = rand_r(&time_seed) % 63;
-               passcode[i] = token[random_num];
+               passkey[i] = token[random_num];
        }
 
-       passcode[4] = '\0';
+       passkey[4] = '\0';
 }
 
-static void LaunchPasscodeInputPopupCallback(app_control_h request, app_control_h reply, app_control_result_e result_e, void *user_data)
+static void LaunchPasskeyInputPopupCallback(app_control_h request, app_control_h reply, app_control_result_e result_e, void *user_data)
 {
        usercallback_info *info = (usercallback_info *)user_data;
 
        int result = -1;
-       char *passcode;
+       char *passkey;
 
        char *reply_message;
        app_control_get_extra_data(reply, "REPLY_MESSAGE", &reply_message);
 
        if (!strcmp(reply_message, "CONNECT")) {
                result = ACLResult_Connect;
-               app_control_get_extra_data(reply, "PASSCODE", &passcode);
+               app_control_get_extra_data(reply, "PASSKEY", &passkey);
        } else if (!strcmp(reply_message, "CANCEL")) {
                result = ACLResult_Cancel;
        } else if (!strcmp(reply_message, "CLOSE")) {
                result = ACLResult_Close;
        }
 
-       info->callback(info->userdata, result, passcode);
+       info->callback(info->userdata, result, passkey);
 }
 
-void conv::acl_manager::LaunchPasscodeInputPopup(PopupCallback callback, void *userdata)
+void conv::acl_manager::LaunchPasskeyInputPopup(PopupCallback callback, void *userdata)
 {
        bundle *b = NULL;
        b = bundle_create();
-       bundle_add(b, "TYPE", "PASSCODE_INPUT_POPUP");
+       bundle_add(b, "TYPE", "PASSKEY_INPUT_POPUP");
 
        int ret = syspopup_launch((char *)"d2d-conv-syspopup", b);
        if (ret != 0) {
@@ -112,18 +112,18 @@ void conv::acl_manager::LaunchPasscodeInputPopup(PopupCallback callback, void *u
        app_control_create(&app_control);
        app_control_set_app_id(app_control, "org.tizen.d2d-conv-syspopup");
        app_control_add_extra_data(app_control, "MESSAGE", "REGIST_CALLBACK");
-       app_control_send_launch_request(app_control, LaunchPasscodeInputPopupCallback, info);
+       app_control_send_launch_request(app_control, LaunchPasskeyInputPopupCallback, info);
        app_control_destroy(app_control);
 }
 
-void conv::acl_manager::LaunchPasscodeShowPopup(const char *deviceName)
+void conv::acl_manager::LaunchPasskeyShowPopup(const char *deviceName)
 {
-       CreatePasscode();
+       CreatePasskey();
 
        bundle *b = NULL;
        b = bundle_create();
-       bundle_add(b, "TYPE", "PASSCODE_SHOW_POPUP");
-       bundle_add(b, "DATA_PASSCODE", passcode);
+       bundle_add(b, "TYPE", "PASSKEY_SHOW_POPUP");
+       bundle_add(b, "DATA_PASSKEY", passkey);
        bundle_add(b, "DATA_DEVICE_NAME", deviceName);
 
        int ret = syspopup_launch((char *)"d2d-conv-syspopup", b);
@@ -140,7 +140,7 @@ static void LaunchToast(char *type)
        app_control_create(&app_control);
        app_control_set_app_id(app_control, "org.tizen.d2d-conv-syspopup");
        app_control_add_extra_data(app_control, "MESSAGE", type);
-       app_control_send_launch_request(app_control, LaunchPasscodeInputPopupCallback, info);
+       app_control_send_launch_request(app_control, LaunchPasskeyInputPopupCallback, info);
        app_control_destroy(app_control);
 }
 
@@ -149,9 +149,9 @@ void conv::acl_manager::LaunchPopupCancelToast()
        LaunchToast((char*)"CANCEL");
 }
 
-void conv::acl_manager::LaunchPasscodeWrongToast()
+void conv::acl_manager::LaunchPasskeyWrongToast()
 {
-       LaunchToast((char*)"WRONG_PASSCODE");
+       LaunchToast((char*)"WRONG_PASSKEY");
 }
 
 void conv::acl_manager::LaunchAccessAllowedToast()
@@ -533,8 +533,7 @@ static void GetACLDeviceList(conv::Request *requestObj)
        delete requestObj;
 }
 
-int conv::acl_manager::handleRequest(conv::Request *requestObj)
-{
+int conv::acl_manager::handleRequest(conv::Request *requestObj) {
        if (!strcmp(requestObj->getSubject(), CONV_SUBJECT_ACCESS_CONTROL_REGIST)) {
                std::string mac_address;
                std::string device_type;

diff --git a/daemon/access_control/ACLManager.h b/daemon/access_control/ACLManager.h
index 662f881..31f43b0 100644 (file)
--- a/daemon/access_control/ACLManager.h
+++ b/daemon/access_control/ACLManager.h
@@ -51,17 +51,17 @@ typedef enum ACLResult {
 namespace conv {
   namespace acl_manager {
 
-    typedef void (*PopupCallback)(void *userdata, int result, char *passcode);
+    typedef void (*PopupCallback)(void *userdata, int result, char *passkey);
 
-    void LaunchPasscodeShowPopup(const char *deviceName);
-    void LaunchPasscodeInputPopup(PopupCallback callback, void *userdata);
+    void LaunchPasskeyShowPopup(const char *deviceName);
+    void LaunchPasskeyInputPopup(PopupCallback callback, void *userdata);
 
     void LaunchPopupCancelToast();
-    void LaunchPasscodeWrongToast();
+    void LaunchPasskeyWrongToast();
     void LaunchAccessAllowedToast();
     void LaunchAccessRejectedToast();
 
-    ACLResult PasscodeChecker (char *input_passcode);
+    ACLResult PasskeyChecker(char *input_passkey);
 
     ACLResult GetACLState(const char *macAddress, ACManagerPolicy *aclState);
     ACLResult AddACLDevice(const char *macAddress, const char *deviceName, const char *deviceIP, ACManagerPolicy *aclState);

diff --git a/daemon/service_provider/RemoteAppControlServiceProvider.cpp b/daemon/service_provider/RemoteAppControlServiceProvider.cpp
index 5e4ec2d..db35ef4 100755 (executable)
--- a/daemon/service_provider/RemoteAppControlServiceProvider.cpp
+++ b/daemon/service_provider/RemoteAppControlServiceProvider.cpp
@@ -246,35 +246,35 @@ static int __access_control(iotcon_request_h request, iotcon_attributes_h attrib
                } else if (acManagerPolicy == ACMANAGER_POLICY_D) {
                        _D("DENIED");
                        policy = CONV_ACCESS_CONTROL_DENIED;
-               } else if (acManagerPolicy == ACMANAGER_POLICY_U){
+               } else if (acManagerPolicy == ACMANAGER_POLICY_U) {
                        _D("UNDECIDED");
                        policy = CONV_ACCESS_CONTROL_DENIED;
                } else if (acManagerPolicy == ACMANAGER_POLICY_U2) {
 #if defined(_D2D_INTERNAL_ACL_)
                        _D("UNDECIDED");
-                       conv::acl_manager::LaunchPasscodeShowPopup(deviceName);
-                       policy = CONV_ACCESS_CONTROL_PASSCODE_REQUEST;
+                       conv::acl_manager::LaunchPasskeyShowPopup(deviceName);
+                       policy = CONV_ACCESS_CONTROL_PASSKEY_REQUEST;
 #endif
                }
                _D("acManagerPolicy:%d", acManagerPolicy);
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_RESPONSE, access_request_type)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_RESPONSE, access_request_type)) {
 #if defined(_D2D_INTERNAL_ACL_)
-               char *input_passcode;
-               ret = iotcon_attributes_get_str(attributes, CONV_JSON_PASSCODE, &input_passcode);
+               char *input_passkey;
+               ret = iotcon_attributes_get_str(attributes, CONV_JSON_PASSKEY, &input_passkey);
                IF_FAIL_RETURN_TAG(ret == IOTCON_ERROR_NONE, CONV_ERROR_INVALID_PARAMETER, _E, "iotcon_attributes_get_str() Fail(%d)", ret);
 
-               ret = conv::acl_manager::PasscodeChecker(input_passcode);
+               ret = conv::acl_manager::PasskeyChecker(input_passkey);
                if (ret == ACLResult_OK) {
-                       policy = CONV_ACCESS_CONTROL_PASSCODE_RIGHT;
+                       policy = CONV_ACCESS_CONTROL_PASSKEY_RIGHT;
                        conv::acl_manager::SetDeviceInfoAndACL(macAddress, deviceType, deviceName, ip.c_str(), ACMANAGER_POLICY_P);
                        conv::acl_manager::LaunchAccessAllowedToast();
-               } else if (ret == ACLResult_Error){
-                       policy = CONV_ACCESS_CONTROL_PASSCODE_WRONG;
+               } else if (ret == ACLResult_Error) {
+                       policy = CONV_ACCESS_CONTROL_PASSKEY_WRONG;
                } else if (ret == ACLResult_Close) {
-                       policy = CONV_ACCESS_CONTROL_PASSCODE_REJECTED;
+                       policy = CONV_ACCESS_CONTROL_PASSKEY_REJECTED;
                }
 #endif
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_CANCEL, access_request_type)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_CANCEL, access_request_type)) {
 #if defined(_D2D_INTERNAL_ACL_)
                _D("Access Cancel Handling");
                policy = CONV_ACCESS_CONTROL_DENIED;
@@ -522,7 +522,7 @@ int conv::RemoteAppControlServiceProvider::release()
        return CONV_ERROR_NONE;
 }
 
-static void passcode_popup_callback(void *user_data, int result, char *passcode);
+static void passkey_popup_callback(void *user_data, int result, char *passkey);
 
 //callback function handles reply from access control request
 static void __on_access_response(iotcon_remote_resource_h resource, iotcon_error_e err,
@@ -569,31 +569,30 @@ static void __on_access_response(iotcon_remote_resource_h resource, iotcon_error
                svcInfo->accessControlState = ACCESS_CONTROL_STATE_PERMITTED;
                sendResponse(result, CONV_JSON_ON_START, CONV_ERROR_NONE, svcInfo->registeredRequest);
                return;
-
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_REQUEST, accessControlResult)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_REQUEST, accessControlResult)) {
 #if defined(_D2D_INTERNAL_ACL_)
-               _D("__on_access_response PASSCODE REQUEST");
-               conv::acl_manager::LaunchPasscodeInputPopup(passcode_popup_callback, svcInfo);
+               _D("__on_access_response PASSKEY REQUEST");
+               conv::acl_manager::LaunchPasskeyInputPopup(passkey_popup_callback, svcInfo);
                return;
 #endif
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_RIGHT, accessControlResult)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_RIGHT, accessControlResult)) {
 #if defined(_D2D_INTERNAL_ACL_)
-               _D("__on_access_response PASSCODE RIGHT");
+               _D("__on_access_response PASSKEY RIGHT");
                conv::acl_manager::LaunchAccessAllowedToast();
                conv::Json result;
                svcInfo->accessControlState = ACCESS_CONTROL_STATE_PERMITTED;
                sendResponse(result, CONV_JSON_ON_START, CONV_ERROR_NONE, svcInfo->registeredRequest);
                return;
 #endif
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_WRONG, accessControlResult)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_WRONG, accessControlResult)) {
 #if defined(_D2D_INTERNAL_ACL_)
-               _D("__on_access_response PASSCODE WRONG");
-               conv::acl_manager::LaunchPasscodeWrongToast();
+               _D("__on_access_response PASSKEY WRONG");
+               conv::acl_manager::LaunchPasskeyWrongToast();
                return;
 #endif
-       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSCODE_REJECTED, accessControlResult)) {
+       } else if (!strcmp(CONV_ACCESS_CONTROL_PASSKEY_REJECTED, accessControlResult)) {
 #if defined(_D2D_INTERNAL_ACL_)
-               _D("__on_access_response PASSCODE REJECTED");
+               _D("__on_access_response PASSKEY REJECTED");
                conv::acl_manager::LaunchAccessRejectedToast();
                conv::Json result;
                svcInfo->accessControlState = ACCESS_CONTROL_STATE_DENIED;
@@ -610,7 +609,7 @@ static void __on_access_response(iotcon_remote_resource_h resource, iotcon_error
 }
 
 #if defined(_D2D_INTERNAL_ACL_)
-static void passcode_popup_callback(void *user_data, int result, char *passcode)
+static void passkey_popup_callback(void *user_data, int result, char *passkey)
 {
        conv::RemoteAppControlServiceInfo *svcInfo = reinterpret_cast<conv::RemoteAppControlServiceInfo*>(user_data);
 
@@ -622,14 +621,14 @@ static void passcode_popup_callback(void *user_data, int result, char *passcode)
 
        if (result == ACLResult_Cancel) {
                iotcon_attributes_add_str(attributes, CONV_JSON_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_REQUEST);
-               iotcon_attributes_add_str(attributes, CONV_JSON_ACCESS_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_PASSCODE_CANCEL);
+               iotcon_attributes_add_str(attributes, CONV_JSON_ACCESS_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_PASSKEY_CANCEL);
                iotcon_attributes_add_str(attributes, CONV_JSON_DEVICE_NAME, (char*)conv::util::getDeviceName().c_str());
                iotcon_attributes_add_str(attributes, CONV_JSON_DEVICE_TYPE, (char*)conv::util::getDeviceType().c_str());
 
        } else if (result == ACLResult_Connect) {
                iotcon_attributes_add_str(attributes, CONV_JSON_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_REQUEST);
-               iotcon_attributes_add_str(attributes, CONV_JSON_ACCESS_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_PASSCODE_RESPONSE);
-               iotcon_attributes_add_str(attributes, CONV_JSON_PASSCODE, passcode);
+               iotcon_attributes_add_str(attributes, CONV_JSON_ACCESS_REQUEST_TYPE, (char*)CONV_ACCESS_CONTROL_PASSKEY_RESPONSE);
+               iotcon_attributes_add_str(attributes, CONV_JSON_PASSKEY, passkey);
                iotcon_attributes_add_str(attributes, CONV_JSON_DEVICE_NAME, (char*)conv::util::getDeviceName().c_str());
                iotcon_attributes_add_str(attributes, CONV_JSON_DEVICE_TYPE, (char*)conv::util::getDeviceType().c_str());
        }