aiot 0.10.0

Rust Link SDK (Aliyun IoT) based on Alink Protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use super::base::*;
use super::recv::*;
use crate::alink::{AlinkRequest, AlinkResponse, ParamsRequest, SysAck};
use crate::{Error, Result, ThreeTuple};
use regex::Regex;
use rumqttc::{AsyncClient, QoS};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::fs;
use std::sync::Arc;
use tokio::sync::{mpsc, oneshot};

impl super::Module {
    pub async fn upload_init(&self, params: InitParams) -> crate::Result<InitData> {
        let payload: InitRequest = ParamsRequest::new(params);
        let topic = format!(
            "/sys/{}/{}/thing/file/upload/mqtt/init",
            self.three.product_key, self.three.device_name
        );
        let (tx, rx) = oneshot::channel();
        self.data.send((payload.id.clone(), tx)).await;
        self.publish(topic, &payload).await?;
        if let Ok(data) = rx.await {
            match data {
                FileRecv::InitReply(reply) => {
                    if reply.code == 200 {
                        return Ok(reply.data);
                    } else {
                        return Err(Error::CodeParams(reply.code, reply.message));
                    }
                }
                _ => {}
            }
        }
        Err(Error::WaitResponseTimeout(payload.id))
    }

    pub async fn upload_send(
        &self,
        params: SendHeaderParams,
        bytes: &[u8],
    ) -> crate::Result<SendReplyData> {
        if params.b_size != bytes.len() {
            return Err(Error::SizeNotMatch(params.b_size, bytes.len()));
        }
        let header: SendHeader = ParamsRequest::new(params);
        let id = header.id.clone();
        let payload = SendPayload::payload(header, bytes)?;
        let topic = format!(
            "/sys/{}/{}/thing/file/upload/mqtt/send",
            self.three.product_key, self.three.device_name
        );
        let (tx, rx) = oneshot::channel();
        self.data.send((id.clone(), tx)).await;
        self.publish_raw(topic, payload).await?;
        if let Ok(data) = rx.await {
            match data {
                FileRecv::SendReply(reply) => {
                    if reply.code == 200 {
                        return Ok(reply.data);
                    } else {
                        return Err(Error::CodeParams(reply.code, reply.message));
                    }
                }
                _ => {}
            }
        }
        Err(Error::WaitResponseTimeout(id))
    }

    pub async fn upload_cancel(&self, params: UploadId) -> crate::Result<UploadId> {
        let payload: CancelRequest = ParamsRequest::new(params);
        let topic = format!(
            "/sys/{}/{}/thing/file/upload/mqtt/cancel",
            self.three.product_key, self.three.device_name
        );
        let (tx, rx) = oneshot::channel();
        self.data.send((payload.id.clone(), tx)).await;
        self.publish(topic, &payload).await?;
        if let Ok(data) = rx.await {
            match data {
                FileRecv::CancelReply(reply) => {
                    if reply.code == 200 {
                        return Ok(reply.data);
                    } else {
                        return Err(Error::CodeParams(reply.code, reply.message));
                    }
                }
                _ => {}
            }
        }
        Err(Error::WaitResponseTimeout(payload.id))
    }
}

/// 设备请求上传文件
/// 请求Topic：`/sys/${productKey}/${deviceName}/thing/file/upload/mqtt/init`。
pub type InitRequest = ParamsRequest<InitParams>;

// 设备上传文件分片
// 请求Topic：`/sys/${productKey}/${deviceName}/thing/file/upload/mqtt/send`。
// SendPayload

/// 设备取消上传文件
/// 请求Topic：/sys/${productKey}/${deviceName}/thing/file/upload/mqtt/cancel。
pub type CancelRequest = ParamsRequest<UploadId>;