pymammotion 0.4.0a3__py3-none-any.whl → 0.4.0a5__py3-none-any.whl

pymammotion/mqtt/linkkit/linkkit.py

@@ -0,0 +1,3023 @@
+#
+# Copyright (c) 2014-2018 Alibaba Group. All rights reserved.
+# License-Identifier: Apache-2.0
+#
+# 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.
+#
+#
+
+import os
+import logging
+import threading
+import queue
+import urllib.request
+import urllib.parse
+import json
+import hashlib
+import hmac
+import random
+import ssl
+import socket
+import string
+import time
+import re
+import sys
+from enum import Enum
+import paho.mqtt.client as mqtt
+from paho.mqtt.enums import CallbackAPIVersion
+
+REQUIRED_MAJOR_VERSION = 3
+REQUIRED_MINOR_VERSION = 5
+
+
+# check Python version
+def lk_check_python_version(major_version, minor_version):
+    version = sys.version_info
+    if version[0] < major_version or (version[0] == major_version and version[1] < minor_version):
+        print("WARNING: linkit requires Python %d.%d or higher, and the current version is %s" % (
+            major_version, minor_version, sys.version))
+
+
+lk_check_python_version(REQUIRED_MAJOR_VERSION, REQUIRED_MINOR_VERSION)
+
+
+class LinkKit(object):
+    TAG_KEY = "attrKey"
+    TAG_VALUE = "attrValue"
+
+    class LinkKitState(Enum):
+        INITIALIZED = 1
+        CONNECTING = 2
+        CONNECTED = 3
+        DISCONNECTING = 4
+        DISCONNECTED = 5
+        DESTRUCTING = 6
+        DESTRUCTED = 7
+
+    class ErrorCode(Enum):
+        SUCCESS = 0
+        # 错误码一共三位数，第一位为0表示为mqtt相关的错误码
+        NETWORK_DISCONNECTED = -0x001    # 当前mqtt连接断开
+        INVALID_TOPIC = -0x002            # 输入的topic为空
+        INVALID_QOS = -0x003             # 输入的qos非法
+        PAHO_MQTT_ERROR = -0x004         # 底层的mqtt报错
+        # 0x100开头的表示为网关相关的错误码
+        NULL_SUBDEV_ERR = -0x101         # 输入的子设备信息为空错误
+        SUBDEV_NOT_ARRAY_ERR = -0x102    # 输入数据并非数组错误
+        ARRAY_LENGTH_ERR = -0x103        # 数组长度错误
+        # 0x300开头的表示为动态注册相关的错误码
+        DYNREG_AUTH_FAILED = -0x301      # 预注册动态注册认证失败
+        DYNREG_AUTH_NWL_FAILED = -0x302  # 免白动态注册认证失败
+        # 0x400开头表示为OTA有关的错误
+        OTA_INVALID_PARAM = -0x401       # 参数非法
+        OTA_DIGEST_MISMATCH = -0x402     # 校验和不通过
+        OTA_PUB_FAILED = -0x403          # 上报失败
+        OTA_INVALID_SIGN_METHOD = -0x404 # 非法校验方法
+        OTA_DOWNLOAD_FAIL = -0x405       # 下载失败
+        OTA_INVALID_URL = -0X406         # 无法访问HTTP链接
+        OTA_INVALID_PATH = -0X407        # 存储路径打开失败
+
+
+    class StateError(Exception):
+        def __init__(self, err):
+            Exception.__init__(self, err)
+
+    class Shadow(object):
+        def __init__(self):
+            self.__version = None
+            self.__timestamp = None
+            self.__state = None
+            self.__metadata = None
+            self.__latest_shadow_lock = threading.Lock()
+            self.__latest_received_time = None
+            self.__lastest_received_payload = None
+
+        def get_version(self):
+            with self.__latest_shadow_lock:
+                return self.__version
+
+        def get_metadata(self):
+            with self.__latest_shadow_lock:
+                return self.__metadata
+
+        def get_state(self):
+            with self.__latest_shadow_lock:
+                return self.__state
+
+        def set_state(self, state):
+            with self.__latest_shadow_lock:
+                self.__state = state
+
+        def set_metadata(self, metadata):
+            with self.__latest_shadow_lock:
+                self.__metadata = metadata
+
+        def set_version(self, version):
+            with self.__latest_shadow_lock:
+                self.__version = version
+
+        def set_timestamp(self, timestamp):
+            with self.__latest_shadow_lock:
+                self.__timestamp = timestamp
+
+        def set_latest_recevied_time(self, timestamp):
+            with self.__latest_shadow_lock:
+                self.__latest_received_time = timestamp
+
+        def get_latest_recevied_time(self):
+            with self.__latest_shadow_lock:
+                return self.__latest_received_time
+
+        def set_latest_recevied_payload(self, payload):
+            with self.__latest_shadow_lock:
+                self.__latest_received_payload = payload
+
+        def get_latest_recevied_payload(self):
+            with self.__latest_shadow_lock:
+                return self.__latest_received_payload
+
+        def to_dict(self):
+            return {'state': self.__state, 'metadata': self.__metadata, 'version': self.__version,
+                    'timestamp': self.__timestamp}
+
+        def to_json_string(self):
+            return json.dumps(self.to_dict())
+
+    class __HandlerTask(object):
+
+        def __init__(self, logger=None):
+            self.__logger = logger
+            if self.__logger is not None:
+                self.__logger.info("HandlerTask init enter")
+            self.__message_queue = queue.Queue(2000)
+            self.__cmd_callback = {}
+            self.__started = False
+            self.__exited = False
+            self.__thread = None
+            pass
+
+        def register_cmd_callback(self, cmd, callback):
+            if self.__started is False:
+                if cmd != "req_exit":
+                    self.__cmd_callback[cmd] = callback
+                    return 0
+                else:
+                    return 1
+                pass
+            else:
+                return 2
+            pass
+
+        def post_message(self, cmd, value):
+            self.__logger.debug("post_message :%r " % cmd)
+            if self.__started and self.__exited is False:
+                try:
+                    self.__message_queue.put((cmd, value), timeout=5)
+                except queue.Full as e:
+                    self.__logger.error("queue full: %r" % e)
+                    return False
+                self.__logger.debug("post_message success")
+                return True
+            self.__logger.debug("post_message fail started:%r,exited:%r" % (self.__started, self.__exited))
+            return False
+            pass
+
+        def start(self):
+            if self.__logger is not None:
+                self.__logger.info("HandlerTask start")
+            if self.__started is False:
+                if self.__logger is not None:
+                    self.__logger.info("HandlerTask try start")
+                self.__exited = False
+                self.__started = True
+                self.__message_queue = queue.Queue(2000)
+                self.__thread = threading.Thread(target=self.__thread_runnable)
+                self.__thread.daemon = True
+                self.__thread.start()
+                return 0
+            return 1
+
+        def stop(self):
+            if self.__started and self.__exited is False:
+                self.__exited = True
+                self.__message_queue.put(("req_exit", None))
+
+        def wait_stop(self):
+            if self.__started is True:
+                self.__thread.join()
+
+        def __thread_runnable(self):
+            if self.__logger is not None:
+                self.__logger.debug("thread runnable enter")
+            while True:
+                cmd, value = self.__message_queue.get()
+                self.__logger.debug("thread runnable pop cmd:%r" % cmd)
+                if cmd == "req_exit":
+                    break
+                if self.__cmd_callback[cmd] is not None:
+                    try:
+                        self.__cmd_callback[cmd](value)
+                    except Exception as e:
+                        if self.__logger is not None:
+                            self.__logger.error("thread runnable raise exception:%s" % e)
+            self.__started = False
+            if self.__logger is not None:
+                self.__logger.debug("thread runnable exit")
+            pass
+
+    class LoopThread(object):
+        def __init__(self, logger=None):
+            self.__logger = logger
+            if logger is not None:
+                self.__logger.info("LoopThread init enter")
+            self.__callback = None
+            self.__thread = None
+            self.__started = False
+            self.__req_wait = threading.Event()
+            if logger is not None:
+                self.__logger.info("LoopThread init exit")
+
+        def start(self, callback):
+            if self.__started is True:
+                self.__logger.info("LoopThread already ")
+                return 1
+            else:
+                self.__callback = callback
+                self.__thread = threading.Thread(target=self.__thread_main)
+                self.__thread.daemon = True
+                self.__thread.start()
+                return 0
+
+        def stop(self):
+            self.__req_wait.wait()
+            self.__req_wait.clear()
+
+        def __thread_main(self):
+            self.__started = True
+            try:
+                if self.__logger is not None:
+                    self.__logger.debug("LoopThread thread enter")
+                if self.__callback is not None:
+                    self.__callback()
+                if self.__logger is not None:
+                    self.__logger.debug("LoopThread thread exit")
+            except Exception as e:
+                self.__logger.error("LoopThread thread Exception:" + str(e))
+            self.__started = False
+            self.__req_wait.set()
+
+    def _on_file_upload_start(self, id, upload_file_info, user_data):
+        if self.__on_file_upload_begin != None:
+            self.__on_file_upload_begin(id, upload_file_info, self.__user_data)
+
+    def _on_file_upload_end(self, id, upload_file_info, upload_file_result, user_data):
+        if self.__on_file_upload_end != None:
+            self.__on_file_upload_end(id, upload_file_info, upload_file_result, self.__user_data)
+
+    def _on_file_upload_progress(self, id, upload_file_result, upload_file_info, user_data):
+        pass
+
+    class __LinkKitLog(object):
+        def __init__(self):
+            self.__logger = logging.getLogger("linkkit")
+            self.__enabled = False
+            pass
+
+        def enable_logger(self):
+            self.__enabled = True
+
+        def disable_logger(self):
+            self.__enabled = False
+
+        def is_enabled(self):
+            return self.__enabled
+
+        def config_logger(self, level):
+            self.__logger.setLevel(level)
+
+        def debug(self, fmt, *args):
+            if self.__enabled:
+                self.__logger.debug(fmt, *args)
+
+        def warring(self, fmt, *args):
+            if self.__enabled:
+                self.__logger.warning(fmt, *args)
+
+        def info(self, fmt, *args):
+            if self.__enabled:
+                self.__logger.info(fmt, *args)
+
+        def error(self, fmt, *args):
+            if self.__enabled:
+                self.__logger.error(fmt, *args)
+
+        def critical(self, fmt, *args):
+            if self.__enabled:
+                self.__logger.critical(fmt, *args)
+
+    __USER_TOPIC_PREFIX = "/%s/%s/%s"
+    __ALIYUN_BROKER_CA_DATA = """
+-----BEGIN CERTIFICATE-----
+MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
+A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
+b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
+MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
+YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
+aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
+jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
+xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
+1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
+snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
+U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
+9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
+AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
+yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
+38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
+AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
+DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
+HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIID3zCCAsegAwIBAgISfiX6mTa5RMUTGSC3rQhnestIMA0GCSqGSIb3DQEBCwUA
+MHcxCzAJBgNVBAYTAkNOMREwDwYDVQQIDAhaaGVqaWFuZzERMA8GA1UEBwwISGFu
+Z3pob3UxEzARBgNVBAoMCkFsaXl1biBJb1QxEDAOBgNVBAsMB1Jvb3QgQ0ExGzAZ
+BgNVBAMMEkFsaXl1biBJb1QgUm9vdCBDQTAgFw0yMzA3MDQwNjM2NThaGA8yMDUz
+MDcwNDA2MzY1OFowdzELMAkGA1UEBhMCQ04xETAPBgNVBAgMCFpoZWppYW5nMREw
+DwYDVQQHDAhIYW5nemhvdTETMBEGA1UECgwKQWxpeXVuIElvVDEQMA4GA1UECwwH
+Um9vdCBDQTEbMBkGA1UEAwwSQWxpeXVuIElvVCBSb290IENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoK//6vc2oXhnvJD7BVhj6grj7PMlN2N4iNH4
+GBmLmMdkF1z9eQLjksYc4Zid/FX67ypWFtdycOei5ec0X00m53Gvy4zLGBo2uKgi
+T9IxMudmt95bORZbaph4VK82gPNU4ewbiI1q2loRZEHRdyPORTPpvNLHu8DrYBnY
+Vg5feEYLLyhxg5M1UTrT/30RggHpaa0BYIPxwsKyylQ1OskOsyZQeOyPe8t8r2D4
+RBpUGc5ix4j537HYTKSyK3Hv57R7w1NzKtXoOioDOm+YySsz9sTLFajZkUcQci4X
+aedyEeguDLAIUKiYicJhRCZWljVlZActorTgjCY4zRajodThrQIDAQABo2MwYTAO
+BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUkWHoKi2h
+DlS1/rYpcT/Ue+aKhP8wHwYDVR0jBBgwFoAUkWHoKi2hDlS1/rYpcT/Ue+aKhP8w
+DQYJKoZIhvcNAQELBQADggEBADrrLcBY7gDXN8/0KHvPbGwMrEAJcnF9z4MBxRvt
+rEoRxhlvRZzPi7w/868xbipwwnksZsn0QNIiAZ6XzbwvIFG01ONJET+OzDy6ZqUb
+YmJI09EOe9/Hst8Fac2D14Oyw0+6KTqZW7WWrP2TAgv8/Uox2S05pCWNfJpRZxOv
+Lr4DZmnXBJCMNMY/X7xpcjylq+uCj118PBobfH9Oo+iAJ4YyjOLmX3bflKIn1Oat
+vdJBtXCj3phpfuf56VwKxoxEVR818GqPAHnz9oVvye4sQqBp/2ynrKFxZKUaJtk0
+7UeVbtecwnQTrlcpWM7ACQC0OO0M9+uNjpKIbksv1s11xu0=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDE
+gMB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2
+JhbFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNM
+zQxMjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBS
+NjETMBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiI
+wDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQ
+ssgrRIxutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuT
+ToVBu1kZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSK
+vGRMIRxDaNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n
+16qIfKtJwLnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9
+CgYXfIWHSw1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJ
+Da38O+2HBNXk7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiW
+m05OWgtH8wY2SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4
+UoQSwC+n+7o/hbguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQ
+Ce24DWJfncBZ4nWUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFl
+WQaYw55PfWzjMpYrZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZ
+cIN5kZeR1BonvzceMgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjA
+PBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToD
+AfBgNVHSMEGDAWgBSubAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFA
+AOCAgEAgyXt6NH9lVLNnsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcW
+c+ZfwFSY1XS+wc3iEZGtIxg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKP
+rmzU+sQghoefEQzd5Mr6155wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waN
+rlU/yDXNOd8v9EDERm8tLjvUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944
+Hn+Xds+qkxV/ZoVqW/hpvvfcDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl
++68KnyBr3TsTjxKM4kEaSHpzoHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU
+3/gKbaKxCXcPu9czc8FB10jZpnOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTO
+wY3WzvUy2MmeFe8nI+z1TIvWfspA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsVi
+VO6LAUP5MSeGbEYNNVMnbrt9x+vJJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9
+x8jvOOJckvB595yEunQtYQEgfn7R8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDf
+LRVpOoERIyNiwmcUVhAn21klJwGW45hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIICCzCCAZGgAwIBAgISEdK7ujNu1LzmJGjFDYQdmOhDMAoGCCqGSM49BAMDME
+YxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGgYD
+VQQDExNHbG9iYWxTaWduIFJvb3QgRTQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2MD
+MyMDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24g
+bnYtc2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBFNDYwdjAQBgcqhkjOPQ
+IBBgUrgQQAIgNiAAScDrHPt+ieUnd1NPqlRqetMhkytAepJ8qUuwzSChDH2omw
+lwxwEwkBjtjqR+q+soArzfwoDdusvKSGN+1wCAB16pMLey5SnCNoIwZD7JIvU4
+Tb+0cUB+hflGddyXqBPCCjQjBAMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBQxCpCPtsad0kRLgLWi5h+xEk8blTAKBggqhkjOPQ
+QDAwNoADBlAjEA31SQ7Zvvi5QCkxeCmb6zniz2C5GMn0oUsfZkvLtoURMMA/cV
+i4RguYv/Uo7njLwcAjA8+RHUjE7AwWHCFUyqqx0LMV87HOIAl0Qx5v5zli/alt
+P+CAezNIm8BZ/3Hobui3A=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIFWjCCA0KgAwIBAgISEdK7udcjGJ5AXwqdLdDfJWfRMA0GCSqGSIb3DQEBDAU
+AMEYxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMRwwGg
+YDVQQDExNHbG9iYWxTaWduIFJvb3QgUjQ2MB4XDTE5MDMyMDAwMDAwMFoXDTQ2M
+DMyMDAwMDAwMFowRjELMAkGA1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24g
+bnYtc2ExHDAaBgNVBAMTE0dsb2JhbFNpZ24gUm9vdCBSNDYwggIiMA0GCSqGSIb
+3DQEBAQUAA4ICDwAwggIKAoICAQCsrHQy6LNl5brtQyYdpokNRbopiLKkHWPd08
+EsCVeJOaFV6Wc0dwxu5FUdUiXSE2te4R2pt32JMl8Nnp8semNgQB+msLZ4j5lUl
+ghYruQGvGIFAha/r6gjA7aUD7xubMLL1aa7DOn2wQL7Id5m3RerdELv8HQvJfTq
+a1VbkNud316HCkD7rRlr+/fKYIje2sGP1q7Vf9Q8g+7XFkyDRTNrJ9CG0Bwta/O
+rffGFqfUo0q3v84RLHIf8E6M6cqJaESvWJ3En7YEtbWaBkoe0G1h6zD8K+kZPT
+Xhc+CtI4wSEy132tGqzZfxCnlEmIyDLPRT5ge1lFgBPGmSXZgjPjHvjK8Cd+RTy
+G/FWaha/LIWFzXg4mutCagI0GIMXTpRW+LaCtfOW3T3zvn8gdz57GSNrLNRyc0N
+XfeD412lPFzYE+cCQYDdF3uYM2HSNrpyibXRdQr4G9dlkbgIQrImwTDsHTUB+JM
+WKmIJ5jqSngiCNI/onccnfxkF0oE32kRbcRoxfKWMxWXEM2G/CtjJ9++ZdU6Z+F
+fy7dXxd7Pj2Fxzsx2sZy/N78CsHpdlseVR2bJ0cpm4O6XkMqCNqo98bMDGfsVR7
+/mrLZqrcZdCinkqaByFrgY/bxFn63iLABJzjqls2k+g9vXqhnQt2sQvHnf3PmKg
+Gwvgqo6GDoLclcqUC4wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQ
+H/BAUwAwEB/zAdBgNVHQ4EFgQUA1yrc4GHqMywptWU4jaWSf8FmSwwDQYJKoZIh
+vcNAQEMBQADggIBAHx47PYCLLtbfpIrXTncvtgdokIzTfnvpCo7RGkerNlFo048
+p9gkUbJUHJNOxO97k4VgJuoJSOD1u8fpaNK7ajFxzHmuEajwmf3lH7wvqMxX63b
+EIaZHU1VNaL8FpO7XJqti2kM3S+LGteWygxk6x9PbTZ4IevPuzz5i+6zoYMzRx6
+Fcg0XERczzF2sUyQQCPtIkpnnpHs6i58FZFZ8d4kuaPp92CC1r2LpXFNqD6v6MV
+enQTqnMdzGxRBF6XLE+0xRFFRhiJBPSy03OXIPBNvIQtQ6IbbjhVp+J3pZmOUdk
+LG5NrmJ7v2B0GbhWrJKsFjLtrWhV/pi60zTe9Mlhww6G9kuEYO4Ne7UyWHmRVSy
+BQ7N0H3qqJZ4d16GLuc1CLgSkZoNNiTW2bKg2SnkheCLQQrzRQDGQob4Ez8pn7f
+XwgNNgyYMqIgXQBztSvwyeqiv5u+YfjyW6hY0XHgL+XVAEV8/+LbzvXMAaq7afJ
+Mbfc2hIkCwU9D9SGuTSyxTDYWnP4vkYxboznxSjBF25cfe1lNj2M8FawTSLfJvd
+kzrnE6JwYZ+vj+vYxXX4M2bUdGc6N3ec592kD3ZDZopD8p/7DEJ4Y9HiD2971KE
+9dJeFt0g5QdYg/NA6s/rob8SKunE3vouXsXgxT7PntgMTzlSdriVZzH81Xwj3QE
+UxeCp6
+-----END CERTIFICATE-----
+    """
+
+    def __init__(self, host_name, product_key, device_name, device_secret, auth_type=None,
+                 username=None, client_id=None, password=None, instance_id=None,
+                 product_secret=None, user_data=None):
+
+        # logging configs
+        self.__just_for_pycharm_autocomplete = False
+
+        def __str_is_empty(value):
+            if value is None or value == "":
+                return True
+            else:
+                return False
+
+        # param check
+        if __str_is_empty(host_name):
+            raise ValueError("host_name wrong")
+        if __str_is_empty(product_key):
+            raise ValueError("product key wrong")
+        if __str_is_empty(device_name):
+            raise ValueError("device name wrong")
+        if __str_is_empty(device_secret) and __str_is_empty(product_secret):
+            lack_other_auth_info = __str_is_empty(username) or __str_is_empty(client_id) or __str_is_empty(password)
+            if lack_other_auth_info:
+                raise ValueError("device secret & product secret are both empty")
+
+        self.__link_log = LinkKit.__LinkKitLog()
+        self.__PahoLog = logging.getLogger("Paho")
+        self.__PahoLog.setLevel(logging.DEBUG)
+
+        # config internal property
+        self.__host_name = host_name
+        self.__product_key = product_key
+        self.__device_name = device_name
+        self.__device_secret = device_secret
+        self.__product_secret = product_secret
+        self.__user_data = user_data
+        self.__device_interface_info = ""
+        self.__device_mac = None
+        self.__cellular_IMEI = None
+        self.__cellular_ICCID = None
+        self.__cellular_IMSI = None
+        self.__cellular_MSISDN = None
+        self.__mqtt_client = None
+        self.__sdk_version = "1.2.13"
+        self.__sdk_program_language = "Python"
+        self.__endpoint = None
+        self.__check_hostname = True
+        self.__instance_id = instance_id
+
+        self.__mqtt_port = 8883
+        self.__mqtt_protocol = "MQTTv311"
+        self.__mqtt_transport = "TCP"
+        self.__mqtt_secure = "TLS"
+        self.__mqtt_keep_alive = 60
+        self.__mqtt_clean_session = True
+        self.__mqtt_max_inflight_message = 20
+        self.__mqtt_max_queued_message = 40
+        self.__mqtt_auto_reconnect_min_sec = 1
+        self.__mqtt_auto_reconnect_max_sec = 60
+        self.__mqtt_auto_reconnect_sec = 0
+        self.__mqtt_request_timeout = 10
+        # 动态注册(免预注册)的flag
+        self.__dynamic_register_nwl_flag = 0
+        # 动态注册(预注册)的flag
+        self.__dynamic_register_flag = 0
+        self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
+        self.__aliyun_broker_ca_data = self.__ALIYUN_BROKER_CA_DATA
+        self.__force_reconnect = False
+
+        self.__latest_shadow = LinkKit.Shadow()
+        self.__auth_type = auth_type
+        self.__username = username
+        self.__client_id = client_id
+        self.__password = password
+
+        # aliyun IoT callbacks
+        self.__on_device_dynamic_register = None
+
+        # mqtt callbacks
+        self.__on_connect = None
+        self.__on_disconnect = None
+        self.__on_publish_topic = None
+        self.__on_subscribe_topic = None
+        self.__on_unsubscribe_topic = None
+        self.__on_topic_message = None
+
+        self.__on_topic_rrpc_message = None
+        self.__on_subscribe_rrpc_topic = None
+        self.__on_unsubscribe_rrpc_topic = None
+
+        # thing model callbacks
+        self.__on_thing_create = None
+        self.__on_thing_enable = None
+        self.__on_thing_disable = None
+        self.__on_thing_raw_data_arrived = None
+        self.__on_thing_raw_data_post = None
+        self.__on_thing_call_service = None
+        self.__on_thing_prop_changed = None
+        self.__on_thing_event_post = None
+        self.__on_thing_prop_post = None
+        self.__on_thing_shadow_get = None
+        self.__on_thing_device_info_update = None
+        self.__on_thing_device_info_delete = None
+
+        self.__on_file_upload_begin = None
+        self.__on_file_upload_end = None
+
+        self.__user_topics = {}
+        self.__user_topics_subscribe_request = {}
+        self.__user_topics_unsubscribe_request = {}
+        self.__user_topics_request_lock = threading.Lock()
+        self.__user_topics_unsubscribe_request_lock = threading.Lock()
+
+        self.__user_rrpc_topics = {}
+        self.__user_rrpc_topics_lock = threading.RLock()
+        self.__user_rrpc_topics_subscribe_request = {}
+        self.__user_rrpc_topics_unsubscribe_request = {}
+        self.__user_rrpc_topics_subscribe_request_lock = threading.RLock()
+        self.__user_rrpc_topics_unsubscribe_request_lock = threading.RLock()
+        self.__user_rrpc_request_ids = []
+        self.__user_rrpc_request_id_index_map = {}
+        self.__user_rrpc_request_ids_lock = threading.RLock()
+        self.__user_rrpc_request_max_len = 100
+
+        # things topic - Alink
+        self.__thing_topic_prop_post = '/sys/%s/%s/thing/event/property/post' % \
+                                       (self.__product_key, self.__device_name)
+        self.__thing_topic_prop_post_reply = self.__thing_topic_prop_post + "_reply"
+        self.__thing_topic_prop_set = '/sys/%s/%s/thing/service/property/set' % \
+                                      (self.__product_key, self.__device_name)
+        self.__thing_topic_prop_set_reply = self.__thing_topic_prop_set + "_reply"
+        self.__thing_topic_prop_get = '/sys/%s/%s/thing/service/property/get' % \
+                                      (self.__product_key, self.__device_name)
+        self.__thing_topic_event_post_pattern = '/sys/%s/%s/thing/event/%s/post'
+        self.__gateway_topic_add_subdev_topo = '/sys/%s/%s/thing/topo/add' % \
+                                               (self.__product_key, self.__device_name)
+        self.__gateway_topic_add_subdev_topo_reply = self.__gateway_topic_add_subdev_topo + "_reply"
+
+        self.__gateway_topic_delete_subdev_topo = '/sys/%s/%s/thing/topo/delete' % \
+                                                  (self.__product_key, self.__device_name)
+        self.__gateway_topic_delete_subdev_topo_reply = self.__gateway_topic_delete_subdev_topo + "_reply"
+
+        self.__gateway_topic_login_subdev = '/ext/session/%s/%s/combine/batch_login' % \
+                                            (self.__product_key, self.__device_name)
+        self.__gateway_topic_login_subdev_reply = self.__gateway_topic_login_subdev + "_reply"
+
+        self.__gateway_topic_logout_subdev = '/ext/session/%s/%s/combine/batch_logout' % \
+                                             (self.__product_key, self.__device_name)
+        self.__gateway_topic_logout_subdev_reply = self.__gateway_topic_logout_subdev + "_reply"
+
+        self.__gateway_topic_register_subdev = '/sys/%s/%s/thing/sub/register' % \
+                                               (self.__product_key, self.__device_name)
+        self.__gateway_topic_register_subdev_reply = self.__gateway_topic_register_subdev + "_reply"
+
+        self.__gateway_topic_product_register_subdev = '/sys/%s/%s/thing/proxy/provisioning/product_register' % \
+                                                       (self.__product_key, self.__device_name)
+        self.__gateway_topic_product_register_subdev_reply = self.__gateway_topic_product_register_subdev + "_reply"
+
+        self.__gateway_topic_topo_change = '/sys/%s/%s/thing/topo/change' % \
+                                           (self.__product_key, self.__device_name)
+        self.__dynamic_register_nwl_topic = '/ext/regnwl'
+        self.__dynamic_register_topic = '/ext/register'
+
+        self.__ota_report_version_topic = '/ota/device/inform/%s/%s' % (self.__product_key, self.__device_name)
+        self.__ota_push_topic = '/ota/device/upgrade/%s/%s' % (self.__product_key, self.__device_name)
+        self.__ota_pull_topic = '/sys/%s/%s/thing/ota/firmware/get' % (self.__product_key, self.__device_name)
+        self.__ota_pull_reply_topic = '/sys/%s/%s/thing/ota/firmware/get_reply' % (
+            self.__product_key, self.__device_name)
+
+        self.__thing_prop_post_mid = {}
+        self.__thing_prop_post_mid_lock = threading.Lock()
+        self.__thing_prop_set_reply_mid = {}
+        self.__thing_prop_set_reply_mid_lock = threading.Lock()
+        self.__gateway_add_subdev_topo_mid = {}
+        self.__gateway_add_subdev_topo_mid_lock = threading.Lock()
+        self.__gateway_delete_subdev_topo_mid = {}
+        self.__gateway_delete_subdev_topo_mid_lock = threading.Lock()
+        # event:post topic
+        self.__thing_topic_event_post = {}
+        self.__thing_topic_event_post_reply = set()
+        self.__thing_events = set()
+        self.__thing_request_id_max = 1000000
+        self.__thing_request_value = 0
+        self.__thing_request_id = {}
+        self.__thing_request_id_lock = threading.Lock()
+        self.__thing_event_post_mid = {}
+        self.__thing_event_post_mid_lock = threading.Lock()
+
+        self.__thing_topic_shadow_get = '/shadow/get/%s/%s' % \
+                                        (self.__product_key, self.__device_name)
+        self.__thing_topic_shadow_update = '/shadow/update/%s/%s' % \
+                                           (self.__product_key, self.__device_name)
+        self.__thing_shadow_mid = {}
+        self.__thing_shadow_mid_lock = threading.Lock()
+
+        # service topic
+        self.__thing_topic_service_pattern = '/sys/%s/%s/thing/service/%s'
+        self.__thing_topic_services = set()
+        self.__thing_topic_services_reply = set()
+        self.__thing_services = set()
+        self.__thing_answer_service_mid = {}
+        self.__thing_answer_service_mid_lock = threading.Lock()
+
+        # thing topic - raw
+        self.__thing_topic_raw_up = '/sys/%s/%s/thing/model/up_raw' % (self.__product_key, self.__device_name)
+        self.__thing_topic_raw_up_reply = self.__thing_topic_raw_up + "_reply"
+        self.__thing_topic_raw_down = '/sys/%s/%s/thing/model/down_raw' % (self.__product_key, self.__device_name)
+        self.__thing_topic_raw_down_reply = self.__thing_topic_raw_down + "_reply"
+        self.__thing_raw_up_mid = {}
+        self.__thing_raw_up_mid_lock = threading.Lock()
+        self.__thing_raw_down_reply_mid = {}
+        self.__thing_raw_down_reply_mid_lock = threading.Lock()
+
+        # thing topic - device_info
+        self.__thing_topic_update_device_info_up = '/sys/%s/%s/thing/deviceinfo/update' % (
+        self.__product_key, self.__device_name)
+        self.__thing_topic_update_device_info_reply = self.__thing_topic_update_device_info_up + "_reply"
+        self.__thing_topic_delete_device_info_up = '/sys/%s/%s/thing/deviceinfo/delete' % (
+        self.__product_key, self.__device_name)
+        self.__thing_topic_delete_device_info_reply = self.__thing_topic_delete_device_info_up + "_reply"
+        self.__thing_update_device_info_up_mid = {}
+        self.__thing_update_device_info_up_mid_lock = threading.Lock()
+        self.__thing_delete_device_info_up_mid = {}
+        self.__thing_delete_device_info_up_mid_lock = threading.Lock()
+
+        # properties
+        self.__thing_properties_set = set()
+        self.__thing_properties_get = set()
+        self.__thing_properties_post = set()
+
+        # thing setup state
+        self.__thing_setup_state = False
+        self.__thing_raw_only = False
+        self.__thing_enable_state = False
+        self.__on_gateway_add_subdev_topo_reply = None
+        self.__on_gateway_delete_subdev_topo_reply = None
+        self.__on_gateway_login_subdev_reply = None
+        self.__on_gateway_logout_subdev_reply = None
+        self.__on_gateway_register_subdev_reply = None
+        self.__on_gateway_product_register_subdev_reply = None
+        self.__on_gateway_topo_change = None
+        self.__on_device_dynamic_register_nwl_reply = None
+        self.__on_ota_message_arrived = None
+
+        if self.__just_for_pycharm_autocomplete:
+            self.__mqtt_client = mqtt.Client(CallbackAPIVersion.VERSION1)
+
+        # device interface info
+        self.__device_info_topic = "/sys/%s/%s/thing/deviceinfo/update" % (self.__product_key, self.__device_name)
+        self.__device_info_topic_reply = self.__device_info_topic + "_reply"
+        self.__device_info_mid_lock = threading.Lock()
+        self.__device_info_mid = {}
+
+        # connect_async
+        self.__connect_async_req = False
+        self.__worker_loop_exit_req = False
+        self.__worker_loop_runing_state = False
+        self.__worker_loop_exit_req_lock = threading.Lock()
+
+        # loop thread
+        self.__loop_thread = LinkKit.LoopThread(self.__link_log)
+
+        # HandlerTask
+        self.__handler_task = LinkKit.__HandlerTask(self.__link_log)
+        self.__handler_task_cmd_on_connect = "on_connect"
+        self.__handler_task_cmd_on_disconnect = "on_disconnect"
+        self.__handler_task_cmd_on_message = "on_message"
+        self.__handler_task_cmd_on_publish = "on_publish"
+        self.__handler_task_cmd_on_subscribe = "on_subscribe"
+        self.__handler_task_cmd_on_unsubscribe = "on_unsubscribe"
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_connect,
+                                                  self.__handler_task_on_connect_callback)
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_disconnect,
+                                                  self.__handler_task_on_disconnect_callback)
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_message,
+                                                  self.__handler_task_on_message_callback)
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_publish,
+                                                  self.__handler_task_on_publish_callback)
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_subscribe,
+                                                  self.__handler_task_on_subscribe_callback)
+        self.__handler_task.register_cmd_callback(self.__handler_task_cmd_on_unsubscribe,
+                                                  self.__handler_task_on_unsubscribe_callback)
+        self.__handler_task.start()
+        pass
+
+    @property
+    def on_device_dynamic_register(self):
+        return None
+
+    @on_device_dynamic_register.setter
+    def on_device_dynamic_register(self, value):
+        self.__on_device_dynamic_register = value
+
+    @property
+    def on_connect(self):
+        return self.__on_connect
+
+    @on_connect.setter
+    def on_connect(self, value):
+        self.__on_connect = value
+        pass
+
+    @property
+    def on_disconnect(self):
+        return self.__on_disconnect
+
+    @on_disconnect.setter
+    def on_disconnect(self, value):
+        self.__on_disconnect = value
+
+    @property
+    def on_publish_topic(self):
+        return None
+
+    @on_publish_topic.setter
+    def on_publish_topic(self, value):
+        self.__on_publish_topic = value
+
+    @property
+    def on_subscribe_topic(self):
+        return None
+
+    @on_subscribe_topic.setter
+    def on_subscribe_topic(self, value):
+        self.__on_subscribe_topic = value
+
+    @property
+    def on_unsubscribe_topic(self):
+        return None
+
+    @on_unsubscribe_topic.setter
+    def on_unsubscribe_topic(self, value):
+        self.__on_unsubscribe_topic = value
+
+    @property
+    def on_topic_message(self):
+        return None
+
+    @on_topic_message.setter
+    def on_topic_message(self, value):
+        self.__on_topic_message = value
+
+    @property
+    def on_topic_rrpc_message(self):
+        return None
+
+    @on_topic_rrpc_message.setter
+    def on_topic_rrpc_message(self, value):
+        self.__on_topic_rrpc_message = value
+
+    @property
+    def on_thing_create(self):
+        return None
+
+    @on_thing_create.setter
+    def on_thing_create(self, value):
+        self.__on_thing_create = value
+
+    @property
+    def on_thing_enable(self):
+        return None
+
+    @on_thing_enable.setter
+    def on_thing_enable(self, value):
+        self.__on_thing_enable = value
+
+    @property
+    def on_thing_disable(self):
+        return None
+
+    @on_thing_disable.setter
+    def on_thing_disable(self, value):
+        self.__on_thing_disable = value
+
+    @property
+    def on_thing_raw_data_arrived(self):
+        return None
+
+    @on_thing_raw_data_arrived.setter
+    def on_thing_raw_data_arrived(self, value):
+        self.__on_thing_raw_data_arrived = value
+
+    @property
+    def on_thing_raw_data_post(self):
+        return self.__on_thing_raw_data_post
+
+    @property
+    def on_thing_device_info_update(self):
+        return self.__on_thing_device_info_update
+
+    @on_thing_device_info_update.setter
+    def on_thing_device_info_update(self, value):
+        self.__on_thing_device_info_update = value
+
+    @property
+    def on_thing_device_info_delete(self):
+        return self.__on_thing_device_info_delete
+
+    @on_thing_device_info_delete.setter
+    def on_thing_device_info_delete(self, value):
+        self.__on_thing_device_info_delete = value
+
+    @on_thing_raw_data_post.setter
+    def on_thing_raw_data_post(self, value):
+        self.__on_thing_raw_data_post = value
+
+    @property
+    def on_thing_call_service(self):
+        return None
+
+    @on_thing_call_service.setter
+    def on_thing_call_service(self, value):
+        self.__on_thing_call_service = value
+
+    @property
+    def on_thing_prop_changed(self):
+        return None
+
+    @on_thing_prop_changed.setter
+    def on_thing_prop_changed(self, value):
+        self.__on_thing_prop_changed = value
+
+    @property
+    def on_thing_event_post(self):
+        return self.__on_thing_event_post
+
+    @on_thing_event_post.setter
+    def on_thing_event_post(self, value):
+        self.__on_thing_event_post = value
+
+    @property
+    def on_thing_prop_post(self):
+        return self.__on_thing_prop_post
+
+    @on_thing_prop_post.setter
+    def on_thing_prop_post(self, value):
+        self.__on_thing_prop_post = value
+
+    @property
+    def on_thing_shadow_get(self):
+        return self.__on_thing_shadow_get
+
+    @on_thing_shadow_get.setter
+    def on_thing_shadow_get(self, value):
+        self.__on_thing_shadow_get = value
+
+    @property
+    def on_file_upload_begin(self):
+        return self.__on_file_upload_begin
+
+    @on_file_upload_begin.setter
+    def on_file_upload_begin(self, value):
+        self.__on_file_upload_begin = value
+
+    @property
+    def on_file_upload_end(self):
+        return self.__on_file_upload_end
+
+    @on_file_upload_end.setter
+    def on_file_upload_end(self, value):
+        self.__on_file_upload_end = value
+
+    @property
+    def on_gateway_add_subdev_topo_reply(self):
+        return None
+
+    @on_gateway_add_subdev_topo_reply.setter
+    def on_gateway_add_subdev_topo_reply(self, value):
+        self.__on_gateway_add_subdev_topo_reply = value
+
+    @property
+    def on_gateway_delete_subdev_topo_reply(self):
+        return None
+
+    @on_gateway_delete_subdev_topo_reply.setter
+    def on_gateway_delete_subdev_topo_reply(self, value):
+        self.__on_gateway_delete_subdev_topo_reply = value
+
+    @property
+    def on_gateway_login_subdev_reply(self):
+        return None
+
+    @on_gateway_login_subdev_reply.setter
+    def on_gateway_login_subdev_reply(self, value):
+        self.__on_gateway_login_subdev_reply = value
+
+    @property
+    def on_gateway_logout_subdev_reply(self):
+        return None
+
+    @on_gateway_logout_subdev_reply.setter
+    def on_gateway_logout_subdev_reply(self, value):
+        self.__on_gateway_logout_subdev_reply = value
+
+    @property
+    def on_gateway_register_subdev_reply(self):
+        return None
+
+    @on_gateway_register_subdev_reply.setter
+    def on_gateway_register_subdev_reply(self, value):
+        self.__on_gateway_register_subdev_reply = value
+
+    @property
+    def on_gateway_product_register_subdev_reply(self):
+        return None
+
+    @on_gateway_product_register_subdev_reply.setter
+    def on_gateway_product_register_subdev_reply(self, value):
+        self.__on_gateway_product_register_subdev_reply = value
+
+    @property
+    def on_device_dynamic_register_nwl_reply(self):
+        return None
+
+    @on_device_dynamic_register_nwl_reply.setter
+    def on_device_dynamic_register_nwl_reply(self, value):
+        self.__on_device_dynamic_register_nwl_reply = value
+
+    @property
+    def on_ota_message_arrived(self):
+        return None
+
+    @on_ota_message_arrived.setter
+    def on_ota_message_arrived(self, value):
+        self.__on_ota_message_arrived = value
+
+    @property
+    def on_gateway_topo_change(self):
+        return None
+
+    @on_gateway_topo_change.setter
+    def on_gateway_topo_change(self, value):
+        self.__on_gateway_topo_change = value
+
+    def enable_logger(self, level):
+        self.__link_log.config_logger(level)
+        self.__link_log.enable_logger()
+        if self.__mqtt_client is not None:
+            self.__mqtt_client.enable_logger(self.__PahoLog)
+        self.__PahoLog.setLevel(level)
+
+    def disable_logger(self):
+        self.__link_log.disable_logger()
+        if self.__mqtt_client is not None:
+            self.__mqtt_client.disable_logger()
+
+    def config_logger(self, level):
+        self.__link_log.config_logger(level)
+        if self.__mqtt_client is not None:
+            self.__PahoLog.setLevel(level)
+
+    def config_http2(self, endpoint=None):
+        raise LinkKit.StateError("not supported any more")
+
+    def config_mqtt(self, port=8883, protocol="MQTTv311", transport="TCP",
+                    secure="TLS", keep_alive=60, clean_session=True,
+                    max_inflight_message=20, max_queued_message=40,
+                    auto_reconnect_min_sec=1,
+                    auto_reconnect_max_sec=60,
+                    cadata=None,
+                    endpoint=None,
+                    check_hostname=True):
+        if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
+            raise LinkKit.StateError("not in INITIALIZED state")
+        if port < 1 or port > 65535:
+            raise ValueError("port wrong")
+        if protocol != "MQTTv311" and protocol != "MQTTv31":
+            raise ValueError("protocol wrong")
+        if transport != "TCP":
+            raise ValueError("transport wrong")
+        if secure != "TLS" and secure != "":
+            raise ValueError("secure wrong")
+        if keep_alive < 30 or keep_alive > 1200:
+            raise ValueError("keep_alive range wrong")
+        if clean_session is not True and clean_session is not False:
+            raise ValueError("clean session wrong")
+        if max_queued_message < 0:
+            raise ValueError("max_queued_message wrong")
+        if max_inflight_message < 0:
+            raise ValueError("max_inflight_message wrong")
+        if auto_reconnect_min_sec < 1 or auto_reconnect_min_sec > 120 * 60:
+            raise ValueError("auto_reconnect_min_sec wrong")
+        if auto_reconnect_max_sec < 1 or auto_reconnect_max_sec > 120 * 60:
+            raise ValueError("auto_reconnect_max_sec wrong")
+        if auto_reconnect_min_sec > auto_reconnect_max_sec:
+            raise ValueError("auto_reconnect_max_sec less than auto_reconnect_min_sec")
+
+        self.__link_log.info("config_mqtt enter")
+        if self.__linkkit_state == LinkKit.LinkKitState.INITIALIZED:
+            if port is not None:
+                self.__mqtt_port = port
+            if protocol is not None:
+                self.__mqtt_protocol = protocol
+            if transport is not None:
+                self.__mqtt_transport = transport
+            if secure is not None:
+                self.__mqtt_secure = secure
+            if keep_alive is not None:
+                self.__mqtt_keep_alive = keep_alive
+            if clean_session is not None:
+                self.__mqtt_clean_session = clean_session
+            if max_inflight_message is not None:
+                self.__mqtt_max_inflight_message = max_inflight_message
+            if max_queued_message is not None:
+                self.__mqtt_max_queued_message = max_queued_message
+            if auto_reconnect_min_sec is not None:
+                self.__mqtt_auto_reconnect_min_sec = auto_reconnect_min_sec
+            if auto_reconnect_max_sec is not None:
+                self.__mqtt_auto_reconnect_max_sec = auto_reconnect_max_sec
+            if cadata is not None:
+                self.__aliyun_broker_ca_data = cadata
+            if endpoint is not None:
+                self.__endpoint = endpoint
+            if check_hostname is not None:
+                self.__check_hostname = check_hostname
+                if False == check_hostname:
+                    self.__link_log.info("skip hostname check")
+
+    def config_device_info(self, interface_info):
+        if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
+            raise LinkKit.StateError("LinkKit object not in INITIALIZED")
+        if not isinstance(interface_info, str):
+            raise ValueError("interface info must be string")
+        if len(interface_info) > 160:
+            return 1
+        self.__device_interface_info = interface_info
+        return 0
+
+    def get_product(self):
+        return self.__product_key
+
+    def get_device_name(self):
+        return self.__device_name
+
+    def get_endpoint(self):
+        return self.__endpoint;
+
+    def get_h2_endpoint(self):
+        raise LinkKit.StateError("not supported any more")
+
+    def get_actual_endpoint(self):
+        return self.__generate_endpoint()
+
+    def get_actual_h2_endpoint(self):
+        raise LinkKit.StateError("not supported any more")
+
+    def __load_json(self, payload):
+        return json.loads(self.__to_str(payload))
+
+    def __to_str(self, payload):
+        if type(payload) is bytes:
+            return str(payload, 'utf-8')
+        else:
+            return payload
+
+    def upload_file_sync(self, local_filename, remote_filename=None, over_write=True,
+                         timeout=None):
+        raise LinkKit.StateError("not supported any more")
+
+    def upload_file_async(self, local_filename, remote_filename=None, over_write=True):
+        raise LinkKit.StateError("not supported any more")
+
+    def __upload_device_interface_info(self):
+        request_id = self.__get_thing_request_id()
+        payload = {
+            "id": request_id,
+            "version": "1.0",
+            "params": [
+                {
+                    "domain": "SYSTEM",
+                    "attrKey": "SYS_SDK_LANGUAGE",
+                    "attrValue": self.__sdk_program_language
+                },
+                {
+                    "domain": "SYSTEM",
+                    "attrKey": "SYS_LP_SDK_VERSION",
+                    "attrValue": self.__sdk_version
+                },
+                {
+                    "domain": "SYSTEM",
+                    "attrKey": "SYS_SDK_IF_INFO",
+                    "attrValue": self.__device_interface_info
+                },
+            ],
+            "method": "thing.deviceinfo.update"
+        }
+        with self.__device_info_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__device_info_topic, json.dumps(payload), 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__device_info_mid[mid] = self.__timestamp()
+                return 0
+            else:
+                return 1
+
+    def destruct(self):
+        if self.__linkkit_state is LinkKit.LinkKitState.DESTRUCTED:
+            self.__link_log.info("LinkKit object has already destructed")
+            return
+        self.__link_log.debug("destruct enter")
+        if self.__linkkit_state == LinkKit.LinkKitState.CONNECTED or \
+                self.__linkkit_state == LinkKit.LinkKitState.CONNECTING:
+            self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTING
+            if self.__connect_async_req:
+                with self.__worker_loop_exit_req_lock:
+                    self.__worker_loop_exit_req = True
+            if self.__mqtt_client is not None:
+                self.__mqtt_client.disconnect()
+            self.__handler_task.wait_stop()
+        else:
+            self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTING
+            if self.__connect_async_req:
+                with self.__worker_loop_exit_req_lock:
+                    self.__worker_loop_exit_req = True
+            self.__handler_task.stop()
+            self.__handler_task.wait_stop()
+            self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
+        pass
+
+    def destroy(self):
+        self.destruct()
+
+    def check_state(self):
+        return self.__linkkit_state
+
+    @staticmethod
+    def __generate_random_str(randomlength=16):
+        """
+        generate radom string
+        """
+        random_str = ""
+        for i in range(randomlength):
+            random_str += random.choice(string.digits + string.ascii_letters)
+        return random_str
+
+    # 基于HTTPS的一型一密预注册
+    def __dynamic_register_device(self):
+        pk = self.__product_key
+        ps = self.__product_secret
+        dn = self.__device_name
+        random_str = self.__generate_random_str(15)
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cadata=self.__aliyun_broker_ca_data)
+        sign_content = "deviceName%sproductKey%srandom%s" % (dn, pk, random_str)
+        sign = hmac.new(ps.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
+        post_data = {
+            "productKey": pk,
+            "deviceName": dn,
+            "random": random_str,
+            "sign": sign,
+            "signMethod": "hmacsha256"
+        }
+        data = urllib.parse.urlencode(post_data)
+        data = data.encode('ascii')
+        request_url = "https://iot-auth.%s.aliyuncs.com/auth/register/device" % self.__host_name
+        with urllib.request.urlopen(request_url, data, context=context) as f:
+            reply_data = f.read().decode('utf-8')
+            reply_obj = self.__load_json(reply_data)
+            if reply_obj["code"] == 200:
+                reply_obj_data = reply_obj["data"]
+                if reply_obj_data is not None:
+                    return 0, reply_obj_data["deviceSecret"]
+                    pass
+            else:
+                return 1, reply_obj["message"]
+
+    def __config_mqtt_client_internal(self):
+        self.__link_log.info("start connect")
+
+        timestamp = str(int(time.time()))
+        if self.__mqtt_secure == "TLS":
+            securemode = 2
+        else:
+            securemode = 3
+        if self.__device_interface_info:
+            sii_option = 'sii=%s,' % (self.__device_interface_info)
+        else:
+            sii_option = ''
+
+        # 普通的一机一密认证方式
+        if self.__is_valid_str(self.__device_secret):
+            client_id = "%s&%s|securemode=%d,signmethod=hmacsha1,ext=1,_ss=1,lan=%s,_v=%s,%stimestamp=%s|" \
+                        % (self.__product_key, self.__device_name, securemode, self.__sdk_program_language,
+                           self.__sdk_version, sii_option, timestamp)
+            username = self.__device_name + "&" + self.__product_key
+            # calc sign
+            sign_content = "clientId%sdeviceName%sproductKey%stimestamp%s" % (
+                self.__product_key + "&" + self.__device_name,
+                self.__device_name,
+                self.__product_key,
+                timestamp)
+            password = hmac.new(self.__device_secret.encode("utf-8"), sign_content.encode("utf-8"),
+                                hashlib.sha1).hexdigest()
+        # 通过username, passwd, cilentid直连接入的方式
+        elif self.__is_valid_str(self.__client_id) and self.__is_valid_str(self.__username) and self.__is_valid_str(
+                self.__password):
+            # 如果已经通过基于mqtt的免预注册一型一密协议获取到了client_id, user_name, password
+            client_id = self.__client_id
+            username = self.__username
+            password = self.__password
+        # 基于mqtt协议的一型一密，包括预注册和非预注册两种, 尝试去获取username, clientid和password
+        elif self.__is_valid_str(self.__product_secret):
+            if self.__auth_type == "regnwl":
+                # 通过一型一密免预注册协议发起认证
+                self.__dynamic_register_nwl_flag = 1
+            elif self.__auth_type == "register":
+                # 通过一型一密预注册协议发起认证
+                self.__dynamic_register_flag = 1
+            else:
+                raise LinkKit.StateError("unknow dynreg param error")
+
+            auth_type_str = self.__auth_type
+            random_str = self.__generate_random_str(15)
+            if self.__is_valid_str(self.__instance_id):
+                client_id = "%s.%s|random=%s,authType=%s,securemode=2,signmethod=hmacsha256,instanceId=%s|" % (
+                    self.__device_name, self.__product_key, random_str, auth_type_str, self.__instance_id)
+            else:
+                client_id = "%s.%s|random=%s,authType=%s,securemode=2,signmethod=hmacsha256|" % (
+                    self.__device_name, self.__product_key, random_str, auth_type_str)
+            username = "%s&%s" % (self.__device_name, self.__product_key)
+            password_src = "deviceName%sproductKey%srandom%s" % (self.__device_name, self.__product_key, random_str)
+            password = hmac.new(self.__product_secret.encode("utf-8"), password_src.encode("utf-8"),
+                                hashlib.sha256).hexdigest()
+        else:
+            raise LinkKit.StateError("unknow auth error")
+
+        # mqtt client start initialize
+        mqtt_protocol_version = mqtt.MQTTv311
+        if self.__mqtt_protocol == "MQTTv311":
+            mqtt_protocol_version = mqtt.MQTTv311
+        elif self.__mqtt_protocol == "MQTTv31":
+            mqtt_protocol_version = mqtt.MQTTv31
+        self.__mqtt_client = mqtt.Client(client_id=client_id,
+                                         clean_session=self.__mqtt_clean_session,
+                                         protocol=mqtt_protocol_version)
+
+        if self.__link_log.is_enabled():
+            self.__mqtt_client.enable_logger(self.__PahoLog)
+        self.__mqtt_client.username_pw_set(username, password)
+        self.__mqtt_client.on_connect = self.__on_internal_connect
+        self.__mqtt_client.on_disconnect = self.__on_internal_disconnect
+        self.__mqtt_client.on_message = self.__on_internal_message
+        self.__mqtt_client.on_publish = self.__on_internal_publish
+        self.__mqtt_client.on_subscribe = self.__on_internal_subscribe
+        self.__mqtt_client.on_unsubscribe = self.__on_internal_unsubscribe
+
+        self.__mqtt_client.reconnect_delay_set(self.__mqtt_auto_reconnect_min_sec, self.__mqtt_auto_reconnect_max_sec)
+        self.__mqtt_client.max_queued_messages_set(self.__mqtt_max_queued_message)
+        self.__mqtt_client.max_inflight_messages_set(self.__mqtt_max_inflight_message)
+
+        # mqtt set tls
+        self.__link_log.debug("current working directory:" + os.getcwd())
+        if self.__mqtt_secure == "TLS":
+            context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cadata=self.__aliyun_broker_ca_data)
+            context.check_hostname = self.__check_hostname
+            self.__mqtt_client.tls_set_context(context)
+        # mqtt client start connect
+        self.__host_name_internal = self.__generate_endpoint()
+
+    def __generate_endpoint(self):
+        if self.__endpoint:
+            return self.__endpoint
+        elif self.__host_name == "127.0.0.1" or self.__host_name == "localhost":
+            return self.__host_name
+        elif self.__is_valid_str(self.__instance_id):
+            return self.__instance_id + ".mqtt.iothub.aliyuncs.com"
+        else:
+            return "%s.iot-as-mqtt.%s.aliyuncs.com" % \
+                   (self.__product_key, self.__host_name)
+
+    def connect(self):
+        raise LinkKit.StateError("not supported")
+
+    def connect_async(self):
+        self.__link_log.debug("connect_async")
+        if self.__linkkit_state not in (LinkKit.LinkKitState.INITIALIZED, LinkKit.LinkKitState.DISCONNECTED):
+            raise LinkKit.StateError("not in INITIALIZED or DISCONNECTED state")
+        self.__connect_async_req = True
+        with self.__worker_loop_exit_req_lock:
+            self.__worker_loop_exit_req = False
+        return self.__loop_thread.start(self.__loop_forever_internal)
+
+    def disconnect(self):
+        self.__link_log.debug("disconnect")
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.info("already disconnected, return")
+            return
+        self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTING
+        if self.__connect_async_req:
+            with self.__worker_loop_exit_req_lock:
+                self.__worker_loop_exit_req = True
+        self.__mqtt_client.disconnect()
+        self.__loop_thread.stop()
+
+    @staticmethod
+    def __check_topic_string(topic):
+        if len(topic) > 128 or len(topic) == 0:
+            raise ValueError("topic string length too long,need decrease %d bytes" % (128 - len(topic)))
+
+    def publish_topic(self, topic, payload=None, qos=1):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, pub fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if topic is None or len(topic) == 0:
+            return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+        if qos != 0 and qos != 1:
+            return LinkKit.ErrorCode.INVALID_QOS.value, None
+        self.__check_topic_string(topic)
+        rc, mid = self.__mqtt_client.publish(topic, payload, qos)
+        if rc == 0:
+            return LinkKit.ErrorCode.SUCCESS.value, mid
+        else:
+            return LinkKit.ErrorCode.PAHO_MQTT_ERROR.value, None
+
+    def subscribe_topic(self, topic, qos=1):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, sub fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if isinstance(topic, tuple):
+            topic, qos = topic
+
+        if isinstance(topic, str):
+            if qos < 0 or qos > 1:
+                return LinkKit.ErrorCode.INVALID_QOS.value, None
+            if topic is None or len(topic) == 0:
+                return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+            self.__check_topic_string(topic)
+            if topic not in self.__user_topics:
+                self.__user_topics_request_lock.acquire()
+                ret = self.__mqtt_client.subscribe(topic, qos)
+                rc, mid = ret
+                if rc == mqtt.MQTT_ERR_SUCCESS:
+                    self.__user_topics_subscribe_request[mid] = [(topic, qos)]
+                self.__user_topics_request_lock.release()
+                if rc == mqtt.MQTT_ERR_SUCCESS:
+                    return 0, mid
+                if rc == mqtt.MQTT_ERR_NO_CONN:
+                    return 2, None
+                return 3, None
+            else:
+                return 1, None
+        elif isinstance(topic, list):
+            topic_qos_list = []
+            user_topic_dict = {}
+            for t, q in topic:
+                if q < 0 or q > 1:
+                    return LinkKit.ErrorCode.INVALID_QOS.value, None
+                if t is None or len(t) == 0 or not isinstance(t, str):
+                    return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+                self.__check_topic_string(t)
+                user_topic_dict[t] = q
+                topic_qos_list.append((t, q))
+            self.__user_topics_request_lock.acquire()
+            ret = self.__mqtt_client.subscribe(topic_qos_list)
+            rc, mid = ret
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__user_topics_subscribe_request[mid] = topic_qos_list
+                self.__link_log.debug("__user_topics_subscribe_request add mid:%d" % mid)
+            self.__user_topics_request_lock.release()
+            return rc, mid
+        else:
+            self.__link_log.error("Parameter type wrong")
+            return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+
+    def unsubscribe_topic(self, topic):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, unsub fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        unsubscribe_topics = []
+        if topic is None or topic == "":
+            return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+        if isinstance(topic, str):
+            self.__check_topic_string(topic)
+            if topic not in self.__user_topics:
+                return 1, None
+            unsubscribe_topics.append(topic)
+        elif isinstance(topic, list):
+            for one_topic in topic:
+                self.__check_topic_string(one_topic)
+                if one_topic in self.__user_topics:
+                    unsubscribe_topics.append(one_topic)
+                else:
+                    pass
+        with self.__user_topics_unsubscribe_request_lock:
+            if len(unsubscribe_topics) == 0:
+                return 2, None
+            ret = self.__mqtt_client.unsubscribe(unsubscribe_topics)
+            rc, mid = ret
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__user_topics_unsubscribe_request[mid] = unsubscribe_topics
+                return ret
+            else:
+                return 1, None
+
+    def __make_rrpc_topic(self, topic):
+        return '/ext/rrpc/+%s' % (topic)
+
+    def subscribe_rrpc_topic(self, topic):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, sub rrpc fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        qos = 0
+        if isinstance(topic, str):
+            if topic is None or len(topic) == 0:
+                return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+            self.__check_topic_string(topic)
+            topic = self.__tidy_topic(topic)
+            rrpc_topic = self.__make_rrpc_topic(topic)
+            with self.__user_rrpc_topics_lock:
+                not_exist = topic not in self.__user_rrpc_topics.keys()
+            if not_exist:
+                with self.__user_rrpc_topics_lock:
+                    self.__user_rrpc_topics[topic] = qos
+                with self.__user_rrpc_topics_subscribe_request_lock:
+                    ret = self.__mqtt_client.subscribe(rrpc_topic, qos)
+                    rc, mid = ret
+                    if rc == mqtt.MQTT_ERR_SUCCESS:
+                        self.__user_rrpc_topics_subscribe_request[mid] = [(rrpc_topic, qos)]
+                    if rc == mqtt.MQTT_ERR_SUCCESS:
+                        return 0, mid
+                    if rc == mqtt.MQTT_ERR_NO_CONN:
+                        return 2, None
+                    return 3, None
+            else:
+                return 1, None
+        elif isinstance(topic, list):
+            topic_qos_list = []
+            for t in topic:
+                if t is None or len(t) == 0 or not isinstance(t, str):
+                    return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+                self.__check_topic_string(t)
+                t = self.__tidy_topic(t)
+                rrpc_t = self.__make_rrpc_topic(t)
+                with self.__user_rrpc_topics_lock:
+                    self.__user_rrpc_topics[t] = qos
+                topic_qos_list.append((rrpc_t, qos))
+            with self.__user_rrpc_topics_subscribe_request_lock:
+                ret = self.__mqtt_client.subscribe(topic_qos_list)
+                rc, mid = ret
+                if rc == mqtt.MQTT_ERR_SUCCESS:
+                    self.__user_rrpc_topics_subscribe_request[mid] = topic_qos_list
+                    self.__link_log.debug("__user_rrpc_topics_subscribe_request add mid:%d" % mid)
+                return rc, mid
+        else:
+            self.__link_log.debug("Parameter type wrong")
+            return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+
+    def unsubscribe_rrpc_topic(self, topic):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, unsub rrpc fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        unsubscribe_topics = []
+        if topic is None or topic == "":
+            return LinkKit.ErrorCode.INVALID_TOPIC.value, None
+        if isinstance(topic, str):
+            self.__check_topic_string(topic)
+            topic = self.__tidy_topic(topic)
+            with self.__user_rrpc_topics_lock:
+                if topic not in self.__user_rrpc_topics:
+                    return 1, None
+            rrpc_topic = self.__make_rrpc_topic(topic)
+            unsubscribe_topics.append(rrpc_topic)
+            with self.__user_rrpc_topics_lock:
+                del self.__user_rrpc_topics[topic]
+
+        elif isinstance(topic, list):
+            for one_topic in topic:
+                self.__check_topic_string(one_topic)
+                one_topic = self.__tidy_topic(one_topic)
+                with self.__user_rrpc_topics_lock:
+                    if one_topic in self.__user_rrpc_topics:
+                        rrpc_topic = self.__make_rrpc_topic(one_topic)
+                        unsubscribe_topics.append(rrpc_topic)
+                        del self.__user_rrpc_topics[one_topic]
+                    else:
+                        pass
+        with self.__user_rrpc_topics_unsubscribe_request_lock:
+            if len(unsubscribe_topics) == 0:
+                return 2, None
+            ret = self.__mqtt_client.unsubscribe(unsubscribe_topics)
+            rc, mid = ret
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__user_rrpc_topics_unsubscribe_request[mid] = unsubscribe_topics
+                return ret
+            else:
+                return 1, None
+
+    def __on_internal_connect_safe(self, client, user_data, session_flag, rc):
+        if rc == 0:
+            self.__reset_reconnect_wait()
+            self.__force_reconnect = False
+        session_flag_internal = {'session present': session_flag}
+        self.__handler_task.post_message(self.__handler_task_cmd_on_connect,
+                                         (client, user_data, session_flag_internal, rc))
+
+    def __loop_forever_internal(self):
+        self.__link_log.debug("enter")
+        self.__linkkit_state = LinkKit.LinkKitState.CONNECTING
+
+        # 为了保持存量设备兼容，保留了基于https的需要预注册的一型一密的预注册
+        if not self.__is_valid_str(self.__device_secret) and self.__is_valid_str(self.__product_secret):
+            lack_other_auth_info = not self.__is_valid_str(self.__username) or not self.__is_valid_str(
+                self.__client_id) or not self.__is_valid_str(self.__password)
+            if not self.__is_valid_str(self.__auth_type) and lack_other_auth_info:
+                rc, value = self.__dynamic_register_device()
+                try:
+                    self.__on_device_dynamic_register(rc, value, self.__user_data)
+                    if rc == 0:
+                        self.__device_secret = value
+                    else:
+                        self.__link_log.error("dynamic register device fail:" + value)
+                        self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
+                        return 1
+                except Exception as e:
+                    self.__link_log.error(e)
+                    self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
+                    return 2
+        try:
+            self.__config_mqtt_client_internal()
+        except ssl.SSLError as e:
+            self.__link_log.error("config mqtt raise exception:" + str(e))
+            self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
+            self.__on_internal_connect_safe(None, None, 0, 6)
+            return
+
+        try:
+            self.__mqtt_client.connect_async(host=self.__host_name_internal, port=self.__mqtt_port,
+                                             keepalive=self.__mqtt_keep_alive)
+        except Exception as e:
+            self.__link_log.error("__loop_forever_internal connect raise exception:" + str(e))
+            self.__linkkit_state = LinkKit.LinkKitState.INITIALIZED
+            self.__on_internal_connect_safe(None, None, 0, 7)
+            return
+        while True:
+            if self.__worker_loop_exit_req:
+                if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
+                    self.__handler_task.stop()
+                    self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
+                break
+            try:
+                self.__linkkit_state = LinkKit.LinkKitState.CONNECTING
+                self.__mqtt_client.reconnect()
+            except (socket.error, OSError) as e:
+                self.__link_log.error(e)
+                # if isinstance(e, socket.timeout):
+                #     self.__link_log.error("connect timeout")
+                #     self.__on_internal_connect_safe(None, None, 0, 8)
+                #     self.__reconnect_wait()
+                #     continue
+                # if isinstance(e, ssl.SSLError):
+                #     self.__on_internal_connect_safe(None, None, 0, 6)
+                #     return
+                if self.__linkkit_state == LinkKit.LinkKitState.CONNECTING:
+                    self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
+                self.__on_internal_connect_safe(None, None, 0, 9)
+                if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
+                    self.__handler_task.stop()
+                    self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
+                    break
+                self.__reconnect_wait()
+                continue
+                # 1. ca wrong 2.socket create timeout 3.connect timeout, call on_connect error
+            # connect success
+            rc = mqtt.MQTT_ERR_SUCCESS
+            while rc == mqtt.MQTT_ERR_SUCCESS:
+                try:
+                    rc = self.__mqtt_client.loop(self.__mqtt_request_timeout)
+                except Exception as e:
+                    self.__link_log.info("loop error:" + str(e))
+                self.__clean_timeout_message()
+                self.__clean_thing_timeout_request_id()
+                if self.__force_reconnect is True:
+                    self.__force_reconnect = False
+                    break
+
+            if self.__linkkit_state == LinkKit.LinkKitState.CONNECTED:
+                self.__on_internal_disconnect(None, None, 1)
+            self.__link_log.info("loop return:%r" % rc)
+
+            if self.__worker_loop_exit_req:
+                if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
+                    self.__handler_task.stop()
+                    self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
+                break
+            self.__reconnect_wait()
+            # 在mqtt + 一型一密免预注册的情况下，由于三元组不对，导致无法与服务器建连,因此需要退出，否则会一直重试
+            if 1 == self.__dynamic_register_nwl_flag:
+                if self.__on_device_dynamic_register_nwl_reply is not None:
+                    self.__on_device_dynamic_register_nwl_reply(LinkKit.ErrorCode.DYNREG_AUTH_NWL_FAILED.value, None,
+                                                                None, None)
+                self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
+                self.__dynamic_register_nwl_flag = 0
+                break
+            # 在mqtt + 一型一密预注册的情况下，由于三元组不对，导致无法与服务器建连,因此需要退出，否则会一直重试
+            if 1 == self.__dynamic_register_flag:
+                if self.__on_device_dynamic_register is not None:
+                    self.__on_device_dynamic_register(LinkKit.ErrorCode.DYNREG_AUTH_FAILED.value, None, None)
+                self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
+                self.__dynamic_register_flag = 0
+                break
+
+    def __clean_timeout_message(self):
+        # self.__link_log.debug("__clean_timeout_message enter")
+        expire_timestamp = self.__timestamp() - self.__mqtt_request_timeout * 1000
+        with self.__thing_prop_post_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_prop_post_mid, expire_timestamp)
+        with self.__thing_event_post_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_event_post_mid, expire_timestamp)
+        with self.__thing_answer_service_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_answer_service_mid, expire_timestamp)
+        with self.__thing_raw_up_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_raw_up_mid, expire_timestamp)
+        with self.__thing_raw_down_reply_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_raw_down_reply_mid, expire_timestamp)
+        with self.__thing_prop_set_reply_mid_lock:
+            self.__clean_timeout_message_item(self.__thing_prop_set_reply_mid, expire_timestamp)
+        self.__clean_timeout_message_item(self.__device_info_mid, expire_timestamp)
+        # self.__link_log.debug("__clean_timeout_message exit")
+
+    def __clean_timeout_message_item(self, mids, expire_time):
+        for mid in list(mids.keys()):
+            if mids[mid] < expire_time:
+                timestamp = mids.pop(mid)
+                self.__link_log.error("__clean_timeout_message_item pop:%r,timestamp:%r", mid, timestamp)
+
+    def __reconnect_wait(self):
+        if self.__mqtt_auto_reconnect_sec == 0:
+            self.__mqtt_auto_reconnect_sec = self.__mqtt_auto_reconnect_min_sec
+        else:
+            self.__mqtt_auto_reconnect_sec = min(self.__mqtt_auto_reconnect_sec * 2, self.__mqtt_auto_reconnect_max_sec)
+            self.__mqtt_auto_reconnect_sec += random.randint(1, self.__mqtt_auto_reconnect_sec)
+        time.sleep(self.__mqtt_auto_reconnect_sec)
+        pass
+
+    def __reset_reconnect_wait(self):
+        self.__mqtt_auto_reconnect_sec = 0
+
+    def start_worker_loop(self):
+        pass
+
+    def thing_setup(self, file=None):
+        if self.__linkkit_state is not LinkKit.LinkKitState.INITIALIZED:
+            raise LinkKit.StateError("not in INITIALIZED state")
+        if self.__thing_setup_state:
+            return 1
+        if file is None:
+            self.__thing_raw_only = True
+            self.__thing_setup_state = True
+            return 0
+        try:
+            with open(file, encoding='utf-8') as f:
+                tsl = json.load(f)
+                index = 0
+                while "events" in tsl and index < len(tsl["events"]):
+                    identifier = tsl["events"][index]["identifier"]
+                    if identifier == "post":
+                        output_data = tsl["events"][index]["outputData"]
+                        output_data_index = 0
+                        while output_data_index < len(output_data):
+                            output_data_item = output_data[output_data_index]["identifier"]
+                            self.__thing_properties_post.add(output_data_item)
+                            output_data_index += 1
+                    else:
+                        self.__thing_events.add(identifier)
+                    index += 1
+                index = 0
+                while "services" in tsl and index < len(tsl["services"]):
+                    identifier = tsl["services"][index]["identifier"]
+                    if identifier == "set":
+                        input_data = tsl["services"][index]["inputData"]
+                        input_data_index = 0
+                        while input_data_index < len(input_data):
+                            input_data_item = input_data[input_data_index]
+                            self.__thing_properties_set.add(input_data_item["identifier"])
+                            input_data_index += 1
+                    elif identifier == "get":
+                        output_data = tsl["services"][index]["outputData"]
+                        output_data_index = 0
+                        while output_data_index < len(output_data):
+                            output_data_item = output_data[output_data_index]
+                            self.__thing_properties_get.add(output_data_item["identifier"])
+                            output_data_index += 1
+                    else:
+                        self.__thing_services.add(identifier)
+                        service_reply_topic = self.__thing_topic_service_pattern % (self.__product_key,
+                                                                                    self.__device_name,
+                                                                                    identifier + "_reply")
+                        self.__thing_topic_services_reply.add(service_reply_topic)
+                    index += 1
+
+                for event in self.__thing_events:
+                    post_topic = self.__thing_topic_event_post_pattern % \
+                                 (self.__product_key, self.__device_name, event)
+                    self.__thing_topic_event_post[event] = post_topic
+                    self.__thing_topic_event_post_reply.add(post_topic + "_reply")
+                # service topic
+                for service in self.__thing_services:
+                    self.__thing_topic_services.add(self.__thing_topic_service_pattern %
+                                                    (self.__product_key, self.__device_name, service))
+
+        except Exception as e:
+            self.__link_log.info("file open error:" + str(e))
+            return 2
+        self.__thing_setup_state = True
+        return 0
+
+    def thing_raw_post_data(self, payload):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, post raw fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value
+        with self.__thing_raw_up_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_raw_up, payload, 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_raw_up_mid[mid] = self.__timestamp()
+                return 0
+        return 1
+
+    def thing_raw_data_reply(self, payload):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, raw data reply fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value
+        with self.__thing_raw_down_reply_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_raw_down_reply, payload, 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_raw_down_reply_mid[mid] = self.__timestamp()
+                return 0
+        return 1
+
+    def thing_update_device_info(self, payload):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, update device info fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            raise LinkKit.StateError("not in SETUP & ENABLE state")
+            return 1, None
+        request_id = self.__get_thing_request_id()
+        with self.__thing_update_device_info_up_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_update_device_info_up,
+                                                 self.__pack_alink_request(request_id, "thing.deviceinfo.update",
+                                                                           payload),
+                                                 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_update_device_info_up_mid[mid] = self.__timestamp()
+                return rc, request_id
+        return 1, None
+
+    def thing_delete_device_info(self, payload):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, delete device info fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            return 1
+        request_id = self.__get_thing_request_id()
+        with self.__thing_delete_device_info_up_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_delete_device_info_up,
+                                                 self.__pack_alink_request(request_id, "thing.deviceinfo.delete",
+                                                                           payload),
+                                                 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_delete_device_info_up_mid[mid] = self.__timestamp()
+                return rc, request_id
+        return 1, None
+
+    def thing_update_tags(self, tagMap):
+        if not isinstance(tagMap, dict):
+            raise ValueError("tagMap must be a dictionary")
+            return 1, None
+
+        payload = []
+        for (k, v) in tagMap.items():
+            payload.append({LinkKit.TAG_KEY: k, LinkKit.TAG_VALUE: v})
+        return self.thing_update_device_info(payload)
+
+    def thing_remove_tags(self, tagKeys):
+        if not isinstance(tagKeys, list) and not isinstance(tagKeys, tuple):
+            raise ValueError("tagKeys must be a list or tuple")
+            return 1, None
+
+        payload = []
+        for tagKey in tagKeys:
+            payload.append({LinkKit.TAG_KEY: tagKey})
+        return self.thing_delete_device_info(payload)
+
+    def __pack_alink_request(self, request_id, method, params):
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": params,
+            "method": method
+        }
+        return json.dumps(request)
+
+    def thing_answer_service(self, identifier, request_id, code, data=None):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, answer service fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            return 1
+        if data is None:
+            data = {}
+        response = {
+            "id": request_id,
+            "code": code,
+            "data": data
+        }
+
+        item = self.__pop_rrpc_service('alink_' + str(request_id))
+        if item:
+            service_reply_topic = item['topic']
+        else:
+            service_reply_topic = self.__thing_topic_service_pattern % (self.__product_key,
+                                                                        self.__device_name,
+                                                                        identifier + "_reply")
+        with self.__thing_answer_service_mid_lock:
+            rc, mid = self.__mqtt_client.publish(service_reply_topic, json.dumps(response), 0)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_answer_service_mid[mid] = self.__timestamp()
+                return 0
+        return 1
+
+    def __get_thing_request_id(self):
+        with self.__thing_request_id_lock:
+            self.__thing_request_value += 1
+            if self.__thing_request_value > self.__thing_request_id_max:
+                self.__thing_request_value = 0
+            if len(self.__thing_request_id) > self.__mqtt_max_queued_message:
+                return None
+            if self.__thing_request_value not in self.__thing_request_id:
+                self.__thing_request_id[self.__thing_request_value] = self.__timestamp()
+                self.__link_log.debug("__get_thing_request_id pop:%r" % self.__thing_request_value)
+                return str(self.__thing_request_value)
+            return None
+
+    def __back_thing_request_id(self, post_id):
+        with self.__thing_request_id_lock:
+            try:
+                self.__thing_request_id.pop(int(post_id))
+            except Exception as e:
+                self.__link_log.error("__back_thing_request_id pop:%r,%r" % (post_id, e))
+
+    def __reset_thing_request_id(self):
+        with self.__thing_request_id_lock:
+            self.__thing_request_value = 0
+            self.__thing_request_id.clear()
+
+    def __clean_thing_timeout_request_id(self):
+        with self.__thing_request_id_lock:
+            expire_timestamp = self.__timestamp() - self.__mqtt_request_timeout * 1000
+            for request_id in list(self.__thing_request_id.keys()):
+                if self.__thing_request_id[request_id] < expire_timestamp:
+                    timestamp = self.__thing_request_id.pop(request_id)
+                    self.__link_log.error("__clean_thing_timeout_request_id pop:%r,timestamp:%r", request_id, timestamp)
+
+    def thing_trigger_event(self, event_tuple):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, trigger event fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            return 1, None
+        if isinstance(event_tuple, tuple):
+            event, params = event_tuple
+        else:
+            return 1, None
+        if event not in self.__thing_topic_event_post.keys():
+            return 1, None
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": {
+                "value": params,
+            },
+            "method": "thing.event.%s.post" % event
+        }
+        with self.__thing_event_post_mid_lock:
+            event_topic = self.__thing_topic_event_post[event]
+            self.__link_log.debug("thing_trigger_event publish topic")
+            rc, mid = self.__mqtt_client.publish(event_topic, json.dumps(request), 0)
+            self.__link_log.debug("thing_trigger_event publish done")
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_event_post_mid[mid] = self.__timestamp()
+                return 0, request_id
+            else:
+                return 1, None
+
+    def thing_post_property(self, property_data):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, post property fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            return 1, None
+        request_params = property_data
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+            "method": "thing.event.property.post"
+        }
+        with self.__thing_prop_post_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_prop_post, json.dumps(request), 1)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_prop_post_mid[mid] = self.__timestamp()
+                return 0, request_id
+            else:
+                return 1, None
+        pass
+
+    def __on_internal_async_message(self, message):
+        self.__link_log.debug("__on_internal_async_message topic:%r" % message.topic)
+        triggered_flag = 0
+
+        if message.topic == self.__thing_topic_prop_set:
+            payload = self.__load_json(message.payload)
+            params = payload["params"]
+            try:
+                reply = {
+                    "id": payload["id"],
+                    "code": 200,
+                    "data": {}
+                }
+                with self.__thing_prop_set_reply_mid_lock:
+                    rc, mid = self.__mqtt_client.publish(self.__thing_topic_prop_set_reply, json.dumps(reply), 1)
+                    if rc == 0:
+                        self.__link_log.info("prop changed reply success,mid:%d" % mid)
+                        self.__thing_prop_set_reply_mid[mid] = self.__timestamp()
+                        self.__link_log.info("prop changed reply success")
+                    else:
+                        self.__link_log.info("prop changed reply fail")
+                    pass
+                if self.__on_thing_prop_changed is not None:
+                    triggered_flag = 1
+                    self.__on_thing_prop_changed(params, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_prop_changed raise exception:%s" % e)
+        elif message.topic == self.__device_info_topic_reply:
+            payload = self.__load_json(message.payload)
+            request_id = payload["id"]
+            code = payload["code"]
+            reply_message = payload["message"]
+            data = payload["data"]
+            self.__back_thing_request_id(request_id)
+            if code != 200:
+                self.__link_log.error("upload device info reply error:%s" % reply_message)
+            try:
+                if self.__on_thing_device_info_update is not None:
+                    triggered_flag = 1
+                    self.__on_thing_device_info_update(request_id, code, data, reply_message, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__thing_topic_prop_post_reply:
+            payload = self.__load_json(message.payload)
+            request_id = payload["id"]
+            code = payload["code"]
+            data = payload["data"]
+            reply_message = payload["message"]
+            try:
+                if self.__on_thing_prop_post is not None:
+                    triggered_flag = 1
+                    self.__on_thing_prop_post(request_id, code, data, reply_message, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_prop_post raise exception:%s" % e)
+            self.__back_thing_request_id(request_id)
+            pass
+        elif message.topic == self.__thing_topic_prop_get:
+            pass
+        elif message.topic in self.__thing_topic_event_post_reply:
+            event = message.topic.split('/', 7)[6]
+            payload = self.__load_json(message.payload)
+            request_id = payload["id"]
+            code = payload["code"]
+            data = payload["data"]
+            reply_message = payload["message"]
+            self.__link_log.info("on_thing_event_post message:%s" % reply_message)
+            try:
+                if self.on_thing_event_post is not None:
+                    triggered_flag = 1
+                    self.on_thing_event_post(event, request_id, code, data, reply_message, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_event_post raise exception:%s" % e)
+            self.__back_thing_request_id(request_id)
+            pass
+        elif message.topic in self.__thing_topic_services:
+            identifier = message.topic.split('/', 6)[6]
+            payload = self.__load_json(message.payload)
+            try:
+                request_id = payload["id"]
+                params = payload["params"]
+                if self.__on_thing_call_service is not None:
+                    triggered_flag = 1
+                    self.__on_thing_call_service(identifier, request_id, params, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_call_service raise exception: %s" % e)
+        elif message.topic == self.__thing_topic_raw_down:
+            try:
+                if self.__on_thing_raw_data_arrived is not None:
+                    triggered_flag = 1
+                    self.__on_thing_raw_data_arrived(message.payload, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_raw_data_arrived process raise exception:%s" % e)
+        elif message.topic == self.__thing_topic_raw_up_reply:
+            try:
+                if self.__on_thing_raw_data_post is not None:
+                    triggered_flag = 1
+                    self.__on_thing_raw_data_post(message.payload, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_raw_post_data process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__thing_topic_update_device_info_reply:
+            try:
+                if self.__on_thing_device_info_update is not None:
+                    triggered_flag = 1
+                    payload = self.__load_json(message.payload)
+                    request_id = payload["id"]
+                    code = payload["code"]
+                    data = payload["data"]
+                    msg = payload['message']
+                    self.__on_thing_device_info_update(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__thing_topic_delete_device_info_reply:
+            try:
+                if self.__on_thing_device_info_delete is not None:
+                    triggered_flag = 1
+                    payload = self.__load_json(message.payload)
+                    request_id = payload["id"]
+                    code = payload["code"]
+                    data = payload["data"]
+                    msg = payload['message']
+                    self.__on_thing_device_info_delete(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_thing_device_info_update process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__thing_topic_shadow_get:
+            self.__try_parse_try_shadow(message.payload)
+            try:
+                if self.__on_thing_shadow_get is not None:
+                    triggered_flag = 1
+                    self.__on_thing_shadow_get(self.__load_json(message.payload), self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_thing_shadow_get process raise exception:%s" % e)
+            pass
+        elif message.topic.startswith("/ext/rrpc/"):
+            triggered_flag = self.__try_parse_rrpc_topic(message)
+            pass
+        elif message.topic == self.__gateway_topic_topo_change:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                params = payload["params"]
+                if self.__on_gateway_topo_change is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_topo_change(request_id, params, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_topo_change process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_add_subdev_topo_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload["message"]
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_add_subdev_topo_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_add_subdev_topo_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_add_subdev_topo_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_delete_subdev_topo_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload["message"]
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_delete_subdev_topo_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_delete_subdev_topo_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_delete_subdev_topo_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_login_subdev_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload["message"]
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_login_subdev_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_login_subdev_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_login_subdev_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_logout_subdev_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload["message"]
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_logout_subdev_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_logout_subdev_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_logout_subdev_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_register_subdev_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload["message"]
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_register_subdev_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_register_subdev_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_register_subdev_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__gateway_topic_product_register_subdev_reply:
+            try:
+                payload = self.__load_json(message.payload)
+                request_id = payload["id"]
+                code = payload["code"]
+                data = payload["data"]
+                msg = payload['message']
+                self.__back_thing_request_id(request_id)
+                if self.__on_gateway_product_register_subdev_reply is not None:
+                    triggered_flag = 1
+                    self.__on_gateway_product_register_subdev_reply(request_id, code, data, msg, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("__on_gateway_product_register_subdev_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__dynamic_register_topic:
+            try:
+                payload = self.__load_json(message.payload)
+                device_secret = payload["deviceSecret"]
+                self.disconnect()
+                self.__dynamic_register_flag = 0
+                if self.__on_device_dynamic_register is not None:
+                    triggered_flag = 1
+                    self.__on_device_dynamic_register(LinkKit.ErrorCode.SUCCESS.value, device_secret, None)
+            except Exception as e:
+                self.__link_log.error("__on_device_dynamic_register process raise exception:%s" % e)
+            pass
+
+        elif message.topic == self.__dynamic_register_nwl_topic:
+            # 一型一密免动态注册获取到username和token
+            try:
+                payload = self.__load_json(message.payload)
+                client_id = payload["clientId"]
+                client_id = client_id + '|authType=connwl,securemode=-2,_ss=1,ext=3,lan=%s,_v=%s|' % (
+                    self.__sdk_program_language, self.__sdk_version)
+                product_key = payload["productKey"]
+                device_name = payload["deviceName"]
+                username = device_name + '&' + product_key
+                password = payload['deviceToken']
+                self.disconnect()
+                self.__dynamic_register_nwl_flag = 0
+                if self.__on_device_dynamic_register_nwl_reply is not None:
+                    triggered_flag = 1
+                    self.__on_device_dynamic_register_nwl_reply(LinkKit.ErrorCode.SUCCESS.value, client_id, username,
+                                                                password)
+            except Exception as e:
+                self.__link_log.error("__on_device_dynamic_register_nwl_reply process raise exception:%s" % e)
+            pass
+        elif message.topic == self.__ota_push_topic or message.topic == self.__ota_pull_reply_topic:
+            try:
+                payload = json.loads(self.__to_str(message.payload))
+                data = payload.setdefault("data", "")
+
+                json_data = json.dumps(data)
+                download_info = json.loads(str(json_data))
+
+                url = download_info.setdefault("url", "")
+                version = download_info.setdefault("version", "")
+                size = download_info.setdefault("size", "")
+                sign_method = download_info.setdefault("signMethod", "")
+                sign = download_info.setdefault("sign", "")
+                extra = download_info.setdefault("extData", "")
+                module = download_info.setdefault("module", "default")
+
+                if not self.__is_valid_str(url) or not self.__is_valid_str(version) or not self.__is_valid_str(size) \
+                        or not self.__is_valid_str(sign_method) or not self.__is_valid_str(sign):
+                    self.__link_log.error("invalid download params")
+                    return
+
+                ota_notice_type = 0
+                if message.topic == self.__ota_push_topic:
+                    ota_notice_type = 1
+                else:
+                    ota_notice_type = 2
+
+                if self.__on_ota_message_arrived is not None:
+                    triggered_flag = 1
+                    self.__on_ota_message_arrived(ota_notice_type, version, size, url, sign_method, sign, module,
+                                                  str(extra))
+            except Exception as e:
+                self.__link_log.error("__on_ota_message_arrived process raise exception:%s" % e)
+            pass
+
+        if triggered_flag == 1:
+            return
+
+        if self.__on_topic_message is not None:
+            try:
+                self.__on_topic_message(message.topic, message.payload, message.qos, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_topic_message process raise exception:%s" % e)
+            pass
+        else:
+            self.__link_log.error("receive unscubscibe topic : %s" % message.topic)
+        pass
+
+    def query_ota_firmware(self, module=None):
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            request_id = "1"
+
+        if self.__is_valid_str(module):
+            payload = "{\"id\": %s, \"params\": {\"module\": \"%s\"}}" % (request_id, module)
+        else:
+            payload = "{\"id\": %s, \"params\": {}}" % request_id
+        pass
+
+        rc = self.__mqtt_client.publish(self.__ota_pull_topic, payload, 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            return 0
+        else:
+            return LinkKit.ErrorCode.OTA_PUB_FAILED
+        pass
+
+    def __cal_file_sign(self, filename, sign_method):
+        if "Md5" == sign_method:
+            hash_tool = hashlib.md5()
+        elif "SHA256" == sign_method:
+            hash_tool = hashlib.sha256()
+        else:
+            return LinkKit.ErrorCode.OTA_INVALID_SIGN_METHOD, -1
+
+        with open(filename, 'rb') as f:
+            while True:
+                chunk = f.read(4096)
+                if not chunk:
+                    break
+                hash_tool.update(chunk)
+        return LinkKit.ErrorCode.SUCCESS, hash_tool.hexdigest()
+
+    def ota_report_version(self, module, version):
+        if not self.__is_valid_str(version):
+            return LinkKit.ErrorCode.OTA_INVALID_PARAM
+
+        request_id = "1"
+        if self.__is_valid_str(module):
+            payload = "{\"id\": %s,\"params\": {\"version\":\"%s\",\"module\": \"%s\"}}" % (request_id, version, module)
+        else:
+            payload = "{\"id\": %s, \"params\": {\"version\": \"%s\"}}" % (request_id, version)
+
+        rc = self.__mqtt_client.publish(self.__ota_report_version_topic, payload, 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            return LinkKit.ErrorCode.SUCCESS
+        else:
+            return LinkKit.ErrorCode.OTA_PUB_FAILED
+
+    def download_ota_firmware(self, url, local_path, sign_method, sign, download_step=10 * 1024):
+        if not self.__is_valid_str(url) or not self.__is_valid_str(local_path) or not self.__is_valid_str(sign_method) \
+                or not self.__is_valid_str(sign):
+            return LinkKit.ErrorCode.OTA_INVALID_PARAM
+
+        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cadata=self.__aliyun_broker_ca_data)
+
+        try:
+            conn = urllib.request.urlopen(url, context=context)
+        except Exception as e:
+            # Return code error (e.g. 404, 501, ...)
+            self.__link_log.error('HTTPError: {} %s' % e)
+            return LinkKit.ErrorCode.OTA_INVALID_URL
+        else:
+            # 200
+            self.__link_log.info('https return 200')
+
+            try:
+                file = open(local_path, 'wb')
+            except IOError as e:
+                self.__link_log.error('open file error: {}' + e.filename)
+                return LinkKit.ErrorCode.OTA_INVALID_PATH
+            else:
+                # Download ota file
+                with file:
+                    while True:
+                        try:
+                            data = conn.read(download_step)
+                        except Exception as e:
+                            self.__link_log.error('download exception %s' % e)
+                            return LinkKit.ErrorCode.OTA_DOWNLOAD_FAIL
+                        else:
+                            if len(data) <= 0:
+                                break
+                            else:
+                                file.write(data)
+
+                # Compare checksum
+                ret, firmware_sign = self.__cal_file_sign(local_path, sign_method)
+                if LinkKit.ErrorCode.SUCCESS == ret and firmware_sign == sign:
+                    self.__link_log.info('sign match')
+                    return LinkKit.ErrorCode.SUCCESS
+                else:
+                    self.__link_log.error('sign mismatch, expect:' + firmware_sign + ", actually:" + sign)
+                    return LinkKit.ErrorCode.OTA_DIGEST_MISMATCH
+
+    def __parse_raw_topic(self, topic):
+        return re.search('/ext/rrpc/.*?(/.*)', topic).group(1)
+
+    def __tidy_topic(self, topic):
+        if topic == None:
+            return None
+        topic = topic.strip()
+        if len(topic) == 0:
+            return None
+        if topic[0] != '/':
+            topic = '/' + topic
+        return topic
+
+    def __push_rrpc_service(self, item):
+        with self.__user_rrpc_request_ids_lock:
+            if len(self.__user_rrpc_request_ids) > self.__user_rrpc_request_max_len:
+                removed_item = self.__user_rrpc_request_ids.pop(0)
+                del self.__user_rrpc_request_id_index_map[removed_item['id']]
+
+        self.__user_rrpc_request_ids.append(item)
+        self.__user_rrpc_request_id_index_map[item['id']] = 0
+
+    def __pop_rrpc_service(self, id):
+        with self.__user_rrpc_request_ids_lock:
+            if id not in self.__user_rrpc_request_id_index_map:
+                return None
+            del self.__user_rrpc_request_id_index_map[id]
+            for index in range(0, len(self.__user_rrpc_request_ids)):
+                item = self.__user_rrpc_request_ids[index]
+                if item['id'] == id:
+                    del self.__user_rrpc_request_ids[index]
+                    return item
+            return None
+
+    def thing_answer_rrpc(self, id, response):
+        item = self.__pop_rrpc_service("rrpc_" + id)
+        if item == None:
+            self.__link_log.error("answer_rrpc_topic, the id does not exist: %s" % id)
+            return 1, None
+        rc, mid = self.__mqtt_client.publish(item['topic'], response, 0)
+        self.__link_log.debug('reply topic:%s' % item['topic'])
+        return rc, mid
+
+    def __try_parse_rrpc_topic(self, message):
+        self.__link_log.debug('receive a rrpc topic:%s' % message.topic)
+        raw_topic = self.__parse_raw_topic(message.topic)
+        triggered = 0
+        # if it is a service, log it...
+        if raw_topic.startswith('/sys') and raw_topic in self.__thing_topic_services:
+            identifier = raw_topic.split('/', 6)[6]
+            payload = self.__load_json(self.__to_str(message.payload))
+            try:
+                request_id = payload["id"]
+                params = payload["params"]
+                item_id = 'alink_' + request_id
+                item = {'id': item_id, 'request_id': request_id, 'payload': payload, 'identifier': identifier,
+                        'topic': message.topic}
+                self.__push_rrpc_service(item)
+                if self.__on_thing_call_service is not None:
+                    triggered = 1
+                    self.__on_thing_call_service(identifier, request_id, params, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_thing_call_service raise exception: %s" % e)
+            return triggered
+
+        # parse
+        with self.__user_rrpc_topics_subscribe_request_lock:
+            with self.__user_rrpc_topics_lock:
+                if raw_topic not in self.__user_rrpc_topics:
+                    self.__link_log.error("%s is not in the rrpc-subscribed list" % raw_topic)
+                    return
+        if not self.__on_topic_rrpc_message:
+            return
+        try:
+            rrpc_id = message.topic.split('/', 4)[3]
+            item_id = 'rrpc_' + rrpc_id
+            item = {'id': item_id, 'payload': message.payload, 'topic': message.topic}
+            self.__push_rrpc_service(item)
+            self.__on_topic_rrpc_message(rrpc_id, message.topic,
+                                         message.payload,
+                                         message.qos,
+                                         self.__user_data)
+            # self.__mqtt_client.publish(message.topic, response, 0)
+            # self.__link_log.debug('reply topic:%s' % message.topic)
+        except Exception as e:
+            self.__link_log.error("on_topic_rrpc_message process raise exception:%r" % e)
+
+    def __try_parse_try_shadow(self, payload):
+        try:
+            self.__latest_shadow.set_latest_recevied_time(self.__timestamp())
+            self.__latest_shadow.set_latest_recevied_payload(payload)
+
+            # parse the pay load
+            msg = self.__load_json(payload)
+            # set version
+            if 'version' in msg:
+                self.__latest_shadow.set_version(msg['version'])
+            elif 'payload' in msg and 'version' in msg['payload']:
+                self.__latest_shadow.set_version(msg['payload']['version'])
+
+            # set timestamp
+            if 'timestamp' in msg:
+                self.__latest_shadow.set_timestamp(msg['timestamp'])
+            elif 'payload' in msg and 'timestamp' in msg['payload']:
+                self.__latest_shadow.set_timestamp(msg['payload']['timestamp'])
+
+            # set state and metadata
+            if 'payload' in msg and msg['payload']['status'] == 'success':
+                if 'state' in msg['payload']:
+                    self.__latest_shadow.set_state(msg['payload']['state'])
+                if 'metadata' in msg['payload']:
+                    self.__latest_shadow.set_metadata(msg['payload']['metadata'])
+        except Exception as e:
+            pass
+
+    def thing_update_shadow(self, reported, version):
+        request = {
+            'state': {'reported': reported},
+            'method': 'update',
+            'version': version
+        }
+        return self.__thing_update_shadow(request)
+
+    def thing_get_shadow(self):
+        request = {'method': 'get'}
+        return self.__thing_update_shadow(request)
+
+    def local_get_latest_shadow(self):
+        return self.__latest_shadow
+
+    def __thing_update_shadow(self, request):
+        if self.__linkkit_state is not LinkKit.LinkKitState.CONNECTED:
+            self.__link_log.error("disconnected, update shadow fail")
+            return LinkKit.ErrorCode.NETWORK_DISCONNECTED.value, None
+        if not self.__thing_setup_state or not self.__thing_enable_state:
+            return 1, None
+        with self.__thing_shadow_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__thing_topic_shadow_update,
+                                                 json.dumps(request), 1)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__thing_shadow_mid[mid] = self.__timestamp()
+                return 0, mid
+            else:
+                return 1, None
+
+    def __on_internal_message(self, client, user_data, message):
+        self.__link_log.info("__on_internal_message")
+        self.__handler_task.post_message(self.__handler_task_cmd_on_message, (client, user_data, message))
+        # self.__worker_thread.async_post_message(message)
+        pass
+
+    def __handler_task_on_message_callback(self, value):
+        client, user_data, message = value
+        self.__on_internal_async_message(message)
+
+    def __on_internal_connect(self, client, user_data, session_flag, rc):
+        self.__link_log.info("__on_internal_connect")
+        if rc == 0:
+            self.__reset_reconnect_wait()
+            # self.__upload_device_interface_info()
+            self.__handler_task.post_message(self.__handler_task_cmd_on_connect, (client, user_data, session_flag, rc))
+
+    def __handler_task_on_connect_callback(self, value):
+        client, user_data, session_flag, rc = value
+        self.__link_log.info("__on_internal_connect enter")
+        self.__link_log.debug("session:%d, return code:%d" % (session_flag['session present'], rc))
+        if rc == 0:
+            self.__linkkit_state = LinkKit.LinkKitState.CONNECTED
+            # self.__worker_thread.start()
+        if self.__on_connect is not None:
+            try:
+                self.__on_connect(session_flag['session present'], rc, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_connect process raise exception:%r" % e)
+        pass
+        if self.__thing_setup_state:
+            self.__thing_enable_state = True
+            if self.__on_thing_enable:
+                self.__on_thing_enable(self.__user_data)
+        return
+
+    def __on_internal_disconnect(self, client, user_data, rc):
+        self.__link_log.info("__on_internal_disconnect enter")
+        if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTING:
+            self.__linkkit_state = LinkKit.LinkKitState.DESTRUCTED
+        elif self.__linkkit_state == LinkKit.LinkKitState.DISCONNECTING:
+            self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
+        elif self.__linkkit_state == LinkKit.LinkKitState.CONNECTED:
+            self.__linkkit_state = LinkKit.LinkKitState.DISCONNECTED
+        elif self.__linkkit_state == LinkKit.LinkKitState.DISCONNECTED:
+            self.__link_log.error("__on_internal_disconnect enter from wrong state:%r" % self.__linkkit_state)
+            return
+        else:
+            self.__link_log.error("__on_internal_disconnect enter from wrong state:%r" % self.__linkkit_state)
+
+            return
+        self.__user_topics.clear()
+        self.__user_topics_subscribe_request.clear()
+        self.__user_topics_unsubscribe_request.clear()
+
+        self.__user_rrpc_topics.clear()
+        self.__user_rrpc_topics_subscribe_request.clear()
+        self.__user_rrpc_topics_unsubscribe_request.clear()
+
+        self.__thing_prop_post_mid.clear()
+        self.__thing_event_post_mid.clear()
+        self.__thing_answer_service_mid.clear()
+        self.__thing_raw_down_reply_mid.clear()
+        self.__thing_raw_up_mid.clear()
+        self.__thing_shadow_mid.clear()
+        self.__device_info_mid.clear()
+        self.__thing_update_device_info_up_mid.clear()
+        self.__thing_delete_device_info_up_mid.clear()
+        self.__handler_task.post_message(self.__handler_task_cmd_on_disconnect, (client, user_data, rc))
+        if self.__linkkit_state == LinkKit.LinkKitState.DESTRUCTED:
+            self.__handler_task.stop()
+
+    def __handler_task_on_disconnect_callback(self, value):
+        self.__link_log.info("__handler_task_on_disconnect_callback enter")
+        client, user_data, rc = value
+        if self.__thing_setup_state:
+            if self.__thing_enable_state:
+                self.__thing_enable_state = False
+                if self.__on_thing_disable is not None:
+                    try:
+                        self.__on_thing_disable(self.__user_data)
+                    except Exception as e:
+                        self.__link_log.error("on_thing_disable process raise exception:%r" % e)
+        if self.__on_disconnect is not None:
+            try:
+                self.__on_disconnect(rc, self.__user_data)
+            except Exception as e:
+                self.__link_log.error("on_disconnect process raise exception:%r" % e)
+
+        pass
+
+    def __on_internal_publish(self, client, user_data, mid):
+        self.__handler_task.post_message(self.__handler_task_cmd_on_publish, (client, user_data, mid))
+
+    def __gateway_add_subdev_topo(self, subdev_array):
+        request_params = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 3)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+            ds = subdev[2]
+            millis = str(self.__timestamp())
+            client_id = pk + "." + dn
+
+            sign_content = "clientId%sdeviceName%sproductKey%stimestamp%s" % (client_id, dn, pk, millis)
+            sign = hmac.new(ds.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
+            params = {
+                "productKey": pk,
+                "deviceName": dn,
+                "clientId": client_id,
+                "timestamp": millis,
+                "signmethod": "hmacSha256",
+                "sign": sign
+            }
+            request_params.append(params)
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        with self.__gateway_add_subdev_topo_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__gateway_topic_add_subdev_topo, json.dumps(request), 1)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__gateway_add_subdev_topo_mid[mid] = self.__timestamp()
+                return 0, request_id
+            else:
+                return 1, None
+        pass
+
+    def gateway_add_subdev_topo(self, subdev_array):
+        return self.__gateway_add_subdev_topo(subdev_array)
+
+    def __validate_subdev_param(self, subdev, expected_len):
+        if subdev is None:
+            return LinkKit.ErrorCode.NULL_SUBDEV_ERR.value
+        if not isinstance(subdev, list):
+            return LinkKit.ErrorCode.SUBDEV_NOT_ARRAY_ERR.value
+        if len(subdev) < expected_len:
+            self.__link_log.error("input subdev length mismatch")
+            return LinkKit.ErrorCode.ARRAY_LENGTH_ERR.value
+        else:
+            return LinkKit.ErrorCode.SUCCESS.value
+
+    def __gateway_delete_subdev_topo(self, subdev_array):
+        request_params = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 2)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+
+            params = {
+                "productKey": pk,
+                "deviceName": dn,
+            }
+            request_params.append(params)
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        with self.__gateway_delete_subdev_topo_mid_lock:
+            rc, mid = self.__mqtt_client.publish(self.__gateway_topic_delete_subdev_topo, json.dumps(request), 1)
+            if rc == mqtt.MQTT_ERR_SUCCESS:
+                self.__gateway_delete_subdev_topo_mid[mid] = self.__timestamp()
+                return 0, request_id
+            else:
+                return 1, None
+        pass
+
+    def gateway_delete_subdev_topo(self, subdev_array):
+        return self.__gateway_delete_subdev_topo(subdev_array)
+
+    def __gateway_login_subdev(self, subdev_array):
+        device_list = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 3)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+            ds = subdev[2]
+            millis = str(self.__timestamp())
+            client_id = pk + "." + dn + "|lan=Python,_v=2.2.1,_ss=1|"
+
+            sign_content = "clientId%sdeviceName%sproductKey%stimestamp%s" % (client_id, dn, pk, millis)
+            sign = hmac.new(ds.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
+            dev_params = {
+                "productKey": pk,
+                "deviceName": dn,
+                "clientId": client_id,
+                "timestamp": millis,
+                "cleanSession": "false",
+                "sign": sign
+            }
+            device_list.append(dev_params)
+        request_params = {
+            "signMethod": "hmacSha256",
+            "deviceList": device_list,
+        }
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        rc, mid = self.__mqtt_client.publish(self.__gateway_topic_login_subdev, json.dumps(request), 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            return 0, request_id
+        else:
+            return 1, None
+
+    def gateway_login_subdev(self, subdev_array):
+        return self.__gateway_login_subdev(subdev_array)
+
+    def gateway_logout_subdev(self, subdev_array):
+        return self.__gateway_logout_subdev(subdev_array)
+
+    def __gateway_logout_subdev(self, subdev_array):
+        request_params = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 2)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+
+            params = {
+                "productKey": pk,
+                "deviceName": dn,
+            }
+            request_params.append(params)
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        rc, mid = self.__mqtt_client.publish(self.__gateway_topic_logout_subdev, json.dumps(request), 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            return 0, request_id
+        else:
+            return 1, None
+        pass
+
+    def __gateway_register_subdev(self, subdev_array):
+        request_params = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 2)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+
+            params = {
+                "productKey": pk,
+                "deviceName": dn,
+            }
+            request_params.append(params)
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        rc, mid = self.__mqtt_client.publish(self.__gateway_topic_register_subdev, json.dumps(request), 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            return 0, request_id
+        else:
+            return 1, None
+
+    def gateway_register_subdev(self, subdev_array):
+        return self.__gateway_register_subdev(subdev_array)
+
+    def gateway_product_register_subdev(self, subdev_array):
+        return self.__gateway_product_register_subdev(subdev_array)
+
+    def __gateway_product_register_subdev(self, subdev_array):
+        device_list = []
+        for subdev in subdev_array:
+            ret = self.__validate_subdev_param(subdev, 3)
+            if ret != 0:
+                return ret, None
+
+            pk = subdev[0]
+            dn = subdev[1]
+            ps = subdev[2]
+            random_str = self.__generate_random_str(15)
+
+            sign_content = "deviceName%sproductKey%srandom%s" % (dn, pk, random_str)
+            sign = hmac.new(ps.encode("utf-8"), sign_content.encode("utf-8"), hashlib.sha256).hexdigest()
+            dev_params = {
+                "productKey": pk,
+                "deviceName": dn,
+                "random": random_str,
+                "signMethod": "hmacSha256",
+                "sign": sign
+            }
+            device_list.append(dev_params)
+        request_params = {
+            "proxieds": device_list,
+        }
+        request_id = self.__get_thing_request_id()
+        if request_id is None:
+            return 1, None
+        request = {
+            "id": request_id,
+            "version": "1.0",
+            "params": request_params,
+        }
+        rc, mid = self.__mqtt_client.publish(self.__gateway_topic_product_register_subdev, json.dumps(request), 0)
+        if rc == mqtt.MQTT_ERR_SUCCESS:
+            self.__link_log.debug("mid for product dynamic register:%d" % mid)
+            return 0, request_id
+        else:
+            return 1, None
+
+    def __handler_task_on_publish_callback(self, value):
+        client, user_data, mid = value
+        self.__link_log.debug("__on_internal_publish message:%d" % mid)
+        with self.__thing_event_post_mid_lock:
+            if mid in self.__thing_event_post_mid:
+                self.__thing_event_post_mid.pop(mid)
+                self.__link_log.debug("__on_internal_publish event post mid removed")
+                return
+        with self.__thing_prop_post_mid_lock:
+            if mid in self.__thing_prop_post_mid:
+                self.__thing_prop_post_mid.pop(mid)
+                self.__link_log.debug("__on_internal_publish prop post mid removed")
+                return
+        with self.__thing_prop_set_reply_mid_lock:
+            if mid in self.__thing_prop_set_reply_mid:
+                self.__thing_prop_set_reply_mid.pop(mid)
+                self.__link_log.debug("__on_internal_publish prop set reply mid removed")
+                return
+        with self.__thing_answer_service_mid_lock:
+            if mid in self.__thing_answer_service_mid:
+                self.__thing_answer_service_mid.pop(mid)
+                self.__link_log.debug("__thing_answer_service_mid mid removed")
+                return
+        with self.__thing_raw_up_mid_lock:
+            if mid in self.__thing_raw_up_mid:
+                self.__thing_raw_up_mid.pop(mid)
+                self.__link_log.debug("__thing_raw_up_mid mid removed")
+                return
+        with self.__thing_raw_down_reply_mid_lock:
+            if mid in self.__thing_raw_down_reply_mid:
+                self.__thing_raw_down_reply_mid.pop(mid)
+                self.__link_log.debug("__thing_raw_down_reply_mid mid removed")
+                return
+        with self.__device_info_mid_lock:
+            if mid in self.__device_info_mid:
+                self.__device_info_mid.pop(mid)
+                self.__link_log.debug("__device_info_mid mid removed")
+                return
+        with self.__thing_shadow_mid_lock:
+            if mid in self.__thing_shadow_mid:
+                self.__thing_shadow_mid.pop(mid)
+                self.__link_log.debug("__thing_shadow_mid mid removed")
+                return
+        with self.__thing_update_device_info_up_mid_lock:
+            if mid in self.__thing_update_device_info_up_mid:
+                self.__thing_update_device_info_up_mid.pop(mid)
+                self.__link_log.debug("__thing_update_device_info_up_mid mid removed")
+                return
+        with self.__thing_delete_device_info_up_mid_lock:
+            if mid in self.__thing_delete_device_info_up_mid:
+                self.__thing_delete_device_info_up_mid.pop(mid)
+                self.__link_log.debug("__thing_delete_device_info_up_mid mid removed")
+                return
+        with self.__gateway_add_subdev_topo_mid_lock:
+            if mid in self.__gateway_add_subdev_topo_mid:
+                self.__gateway_add_subdev_topo_mid.pop(mid)
+                self.__link_log.debug("__gateway_add_subdev_topo_mid removed")
+                return
+        with self.__gateway_delete_subdev_topo_mid_lock:
+            if mid in self.__gateway_delete_subdev_topo_mid:
+                self.__gateway_delete_subdev_topo_mid.pop(mid)
+                self.__link_log.debug("__gateway_delete_subdev_topo_mid removed")
+                return
+        if self.__on_publish_topic is not None:
+            self.__on_publish_topic(mid, self.__user_data)
+        pass
+
+    def __on_internal_subscribe(self, client, user_data, mid, granted_qos):
+        self.__handler_task.post_message(self.__handler_task_cmd_on_subscribe, (client, user_data, mid, granted_qos))
+
+    def __handler_task_on_subscribe_callback(self, value):
+        client, user_data, mid, granted_qos = value
+        self.__link_log.debug("__on_internal_subscribe mid:%d  granted_qos:%s" %
+                              (mid, str(','.join('%s' % it for it in granted_qos))))
+        # try to read rrpc
+        with self.__user_rrpc_topics_subscribe_request_lock:
+            if mid in self.__user_rrpc_topics_subscribe_request:
+                self.__user_rrpc_topics_subscribe_request.pop(mid)
+                if self.__on_subscribe_rrpc_topic:
+                    try:
+                        self.__on_subscribe_rrpc_topic(mid, granted_qos, self.__user_data)
+                    except Exception as err:
+                        self.__link_log.error('Caught exception in on_subscribe_topic: %s', err)
+                return
+
+        # try to read other topic
+        topics_requests = None
+        self.__user_topics_request_lock.acquire()
+        if mid in self.__user_topics_subscribe_request:
+            topics_requests = self.__user_topics_subscribe_request.pop(mid)
+        self.__user_topics_request_lock.release()
+        if topics_requests is not None:
+            return_topics = []
+            for index in range(len(topics_requests)):
+                if granted_qos[index] < 0 or granted_qos[index] > 1:
+                    self.__link_log.error("topics:%s, granted wrong:%d" %
+                                          (topics_requests[index], granted_qos[index]))
+                else:
+                    self.__user_topics[topics_requests[index][0]] = granted_qos[index]
+                return_topics.append((topics_requests[index], granted_qos[index]))
+        if self.__on_subscribe_topic is not None:
+            try:
+                self.__on_subscribe_topic(mid, granted_qos, self.__user_data)
+            except Exception as err:
+                self.__link_log.error('Caught exception in on_subscribe_topic: %s', err)
+        pass
+
+    def __on_internal_unsubscribe(self, client, user_data, mid):
+        self.__handler_task.post_message(self.__handler_task_cmd_on_unsubscribe, (client, user_data, mid))
+
+    def __handler_task_on_unsubscribe_callback(self, value):
+        client, user_data, mid = value
+        self.__link_log.debug("__on_internal_unsubscribe mid:%d" % mid)
+        unsubscribe_request = None
+        # try to read rrpc
+        with self.__user_rrpc_topics_unsubscribe_request_lock:
+            if mid in self.__user_rrpc_topics_unsubscribe_request:
+                self.__user_rrpc_topics_unsubscribe_request.pop(mid)
+                if self.__on_unsubscribe_rrpc_topic:
+                    try:
+                        self.__on_unsubscribe_rrpc_topic(mid, self.__user_data)
+                    except Exception as err:
+                        self.__link_log.error('Caught exception in on_unsubscribe_rrpc_topic: %s', err)
+                return
+
+        with self.__user_topics_unsubscribe_request_lock:
+            if mid in self.__user_topics_unsubscribe_request:
+                unsubscribe_request = self.__user_topics_unsubscribe_request.pop(mid)
+                pass
+        if unsubscribe_request is not None:
+            for t in unsubscribe_request:
+                self.__link_log.debug("__user_topics:%s" % str(self.__user_topics))
+                try:
+                    self.__user_topics.pop(t)
+                except Exception as e:
+                    self.__link_log.error("__on_internal_unsubscribe e:" + str(e))
+                    return
+        if self.__on_unsubscribe_topic is not None:
+            try:
+                self.__on_unsubscribe_topic(mid, self.__user_data)
+            except Exception as err:
+                self.__link_log.error('Caught exception in on_unsubscribe_topic: %s', err)
+
+    def dump_user_topics(self):
+        return self.__user_topics
+
+    def force_reconnect(self):
+        self.__link_log.error("force reconnecting")
+        self.__force_reconnect = True
+
+    @staticmethod
+    def to_user_topic(topic):
+        topic_section = topic.split('/', 3)
+        user_topic = topic_section[3]
+        return user_topic
+
+    def to_full_topic(self, topic):
+        return self.__USER_TOPIC_PREFIX % (self.__product_key, self.__device_name, topic)
+
+    def __is_valid_str(self, user_str):
+        if user_str is None or user_str == "":
+            return False
+        return True
+
+    @staticmethod
+    def __timestamp():
+        return int(time.time() * 1000)