示例代码（新）

本文介绍扫地机 SDK P2P 相关操作的示例代码。

class SweeperP2PKitActivity : AppCompatActivity(), SweeperFileTransListener {

    private lateinit var sweeperCacheFile: String
    private var mSweeperP2P: IThingSweeperP2PKit? = null
    private var devId: String = ""
    private var isCreate = false

    companion object{
        const val TAG = "P2pNativeConnectActivity_TAG"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_p2p_connect)

        //get device id
        devId = intent.getStringExtra("deviceId").toString()

        val iThingSweeperKitSdk = ThingOptimusSdk.getManager(
            IThingSweeperKitSdk::class.java
        )
        mSweeperP2P = iThingSweeperKitSdk.newSweeperP2PKitInstance(devId)
        mSweeperP2P?.initP2PSDKWithUserId(ThingInitConfig().apply {
            this.userId = ThingHomeSdk.getUserInstance()?.user?.uid
        }, object : SweeperP2PKitCallback {
            override fun onError(errorCode: Int, errorMsg: String?) {
                showLog("init error: ${errorCode}, msg: $errorMsg")
            }

            override fun onSuccess() {
                showLog("init success")
            }
        })
        mSweeperP2P?.addFileTransListener(this)

        /**
         *  CacheFilePath
         */
        sweeperCacheFile =
            FileUtil.getSDPath(this) + File.separator + "Sweeper" + File.separator + "Cache" + File.separator + "map" + File.separator
        FileUtil.createDir(sweeperCacheFile)
        val file = File(sweeperCacheFile)
        FileUtil.deleteFile(file)

        isCreate = true
    }

    private fun connectDevice() {
        mSweeperP2P?.connectDevice(devId, ThingConnConfig().apply {
            this.mode = 1
            this.timeout = 15000
        }, object : SweeperP2PKitCallback {
            override fun onSuccess() {
                showLog("p2p connect success")
                querySweeperFile()
            }

            override fun onError(errorCode: Int, errorMsg: String?) {
                showLog("p2p connect error：${errorCode}, msg: $errorMsg")
            }
        })
    }

    private fun querySweeperFile() {
        showLog("start query sweeper file...")
        mSweeperP2P?.querySweeperFile(
            devId,
            SweeperP2pUtil.ALBUM_NAME,
            object : SweeperP2PKitDataCallback<List<ThingAlbumFileIndex?>?> {
                override fun onSuccess(result: List<ThingAlbumFileIndex?>?) {
                    result?.apply {
                        showLog("query sweeper file success：${size}")
                        if (isNotEmpty()) {
                            downFile(DownloadType.P2PDownloadTypeStill.type, result)
                        }
                    }
                }

                override fun onError(errorCode: Int, errorMsg: String?) {
                    showLog("query sweeper file error：${errorCode}, msg: $errorMsg")
                }

            })
    }

    private fun downFile(type: Int, result: List<ThingAlbumFileIndex?>) {
        showLog("start down file...")
        val unCachedList: MutableList<String> = ArrayList()
        if (result.isEmpty()) {
            return
        }
        for (itemBean in result) {
            if (!TextUtils.isEmpty(itemBean?.filename)) {
                val path: String = sweeperCacheFile + itemBean?.filename
                val file = File(path)
                if (file.exists()) {
                    file.delete()
                }
                if (type == DownloadType.P2PDownloadTypeOnce.type) {
                    itemBean?.filename?.let {
                        if (!it.endsWith(".stream")) {
                            unCachedList.add(itemBean.filename)
                        }
                    }
                } else if (type == DownloadType.P2PDownloadTypeStill.type) {
                    if (itemBean?.filename!!.endsWith(".stream")) {
                        unCachedList.add(itemBean.filename)
                    }
                }
            }
        }
        if (unCachedList.size > 0) {
            showLog("down file size：${unCachedList.size}")
            val jsonFiles = JSON.toJSONString(
                DownloadAlbumFiledBean2(
                    unCachedList
                )
            )
            mSweeperP2P?.downloadFile(devId, ThingDownloadFile().apply {
                this.filePath = sweeperCacheFile
                this.albumName = SweeperP2pUtil.ALBUM_NAME
                this.jsonfiles = jsonFiles
            }, object : SweeperP2PKitCallback {
                override fun onSuccess() {
                    showLog("downloadFile run success")
                }

                override fun onError(errorCode: Int, errorMsg: String?) {
                    showLog("downloadFile run error：${errorCode}, msg: $errorMsg")
                }

            })
        } else {
            showLog("downloadFile size is 0")
        }
    }

    private fun cancelDownload() {
        showLog("cancelDownload start")
        mSweeperP2P?.cancelDownload(devId, object : SweeperP2PKitCallback {
            override fun onSuccess() {
                showLog("cancelDownload success")
            }

            override fun onError(errorCode: Int, errorMsg: String?) {
                showLog("cancelDownload error：${errorCode}, msg: $errorMsg")
            }

        })
    }

    private fun showLog(log: String) {
        L.d(TAG, log)
    }

    override fun onDestroy() {
        super.onDestroy()
        mSweeperP2P?.removeFileTransListener(this)
        cancelDownload()
        disconnectDevice()
        deInit()
    }

    private fun deInit() {
        mSweeperP2P?.deInit(object : SweeperP2PKitCallback {
            override fun onSuccess() {
                showLog("deInit onSuccess")
            }

            override fun onError(errorCode: Int, errorMsg: String?) {
                showLog("deInit error：${errorCode}, msg: $errorMsg")
            }

        })
    }

    private fun disconnectDevice() {
        mSweeperP2P?.disconnectDevice(devId, object : SweeperP2PKitCallback {
            override fun onSuccess() {
                showLog("disconnect Success")
            }

            override fun onError(errorCode: Int, errorMsg: String?) {
                showLog("disconnect onError：${errorCode}, msg: $errorMsg")
            }

        })
    }

    override fun onResume() {
        super.onResume()
        val isActive = mSweeperP2P?.isActiveSync(devId)
        showLog("isActive:$isActive")
        if (isActive != true && isCreate) {
           connectDevice()
        }
    }

    override fun onFileFinished(complete: ThingDownloadComplete) {
        showLog("File Finished index=${complete.index} , ${complete.fileName}")
    }

    override fun onFileProgress(progress: ThingDownloadProgress) {
        showLog("progress: ${progress.progress},${progress.fileName}")
    }

    override fun onFileTotalProgress(totalProgress: ThingDownloadTotalProgress) {
        showLog("Total progress: ${totalProgress.progress}")
    }

    override fun onSessionStatusChanged(status: ThingSessionStatus) {
        showLog("connect statues: ${status.status}")
    }
}