feat: 初步接入米家小爱音箱

Author: Soulter

astrbot/core/config/default.py

@@ -105,6 +105,17 @@
                         "host": "localhost",
                         "port": 11451,
                     },
+                    "mispeaker(小爱音箱)": {
+                        "id": "mispeaker",
+                        "type": "mispeaker",
+                        "enable": False,
+                        "username": "",
+                        "password": "",
+                        "did": "",
+                        "activate_word": "测试",
+                        "deactivate_word": "停止",
+                        "interval": 1,
+                    },
                 },
                 "items": {
                     "id": {

astrbot/core/platform/manager.py

@@ -27,6 +27,8 @@ def __init__(self, config: AstrBotConfig, event_queue: Queue):
                     from .sources.vchat.vchat_platform_adapter import VChatPlatformAdapter # noqa: F401
                 case "gewechat":
                     from .sources.gewechat.gewechat_platform_adapter import GewechatPlatformAdapter # noqa: F401
+                case "mispeaker":
+                    from .sources.mispeaker.mispeaker_adapter import MiSpeakerPlatformAdapter # noqa: F401
 
 
     async def initialize(self):

astrbot/core/platform/sources/mispeaker/client.py

@@ -0,0 +1,137 @@
+import os
+import json
+import asyncio
+import aiohttp
+import time
+import traceback
+from .miservice import MiAccount, MiNAService, MiIOService, miio_command, miio_command_help
+from astrbot.core import logger
+from astrbot.api.platform import AstrBotMessage, MessageMember, MessageType
+from astrbot.api.message_components import Plain, Image, At
+
+class SimpleMiSpeakerClient():
+    '''
+    @author: Soulter
+    @references: https://github.com/yihong0618/xiaogpt/blob/main/xiaogpt/xiaogpt.py
+    '''
+    def __init__(self, config: dict):
+        self.username = config['username']
+        self.password = config['password']
+        self.did = config['did']
+        self.store = os.path.join("data", '.mi.token')
+        self.interval = float(config.get('interval', 1))
+        
+        self.conv_query_cookies = {
+            'userId': '',
+            'deviceId': '',
+            'serviceToken': ''
+        }
+        
+        self.MI_CONVERSATION_URL = "https://userprofile.mina.mi.com/device_profile/v2/conversation?source=dialogu&hardware={hardware}&timestamp={timestamp}&limit=1"
+        
+        self.session = aiohttp.ClientSession()
+    
+        self.activate_word = config.get('activate_word', '测试')
+        self.deactivate_word = config.get('deactivate_word', '停止')
+        
+        self.entered = False
+        
+    async def initialize(self):
+        account = MiAccount(self.session, self.username, self.password, self.store)
+        self.miio_service = MiIOService(account) # 小米设备服务
+        self.mina_service = MiNAService(account) # 小爱音箱服务
+        
+        device = await self.get_mina_device()
+        
+        self.deviceID = device['deviceID']
+        self.hardware = device['hardware']
+        
+        with open(self.store, 'r') as f:
+            data = json.load(f)
+            self.userId = data['userId']
+            self.serviceToken = data['micoapi'][1]
+        self.conv_query_cookies['userId'] = self.userId
+        self.conv_query_cookies['deviceId'] = self.deviceID
+        self.conv_query_cookies['serviceToken'] = self.serviceToken
+        
+        logger.info(f"MiSpeakerClient initialized. Conv cookies: {self.conv_query_cookies}. Hardware: {self.hardware}")
+
+    async def get_mina_device(self) -> dict:
+        devices = await self.mina_service.device_list()
+        for device in devices:
+            if device['miotDID'] == self.did:
+                logger.info(f"找到设备 {device['alias']}({device['name']}) 了！")
+                return device
+            
+    async def get_conv(self) -> str:
+        # 时区请确保为北京时间
+        async with aiohttp.ClientSession() as session:
+            session.cookie_jar.update_cookies(self.conv_query_cookies)
+            query_ts = int(time.time())*1000
+            logger.debug(f"Querying conversation at {query_ts}")
+            async with session.get(self.MI_CONVERSATION_URL.format(hardware=self.hardware, timestamp=str(query_ts))) as resp:
+                json_blob = await resp.json()
+                if json_blob['code'] == 0:
+                    data = json.loads(json_blob['data'])
+                    records = data.get('records', None)
+                    for record in records:
+                        if record['time'] >= query_ts - self.interval*1000:
+                            return record['query']
+                else:
+                    logger.error(f"Failed to get conversation: {json_blob}")
+        
+        return None
+                        
+    async def start_pooling(self):
+        while True:
+            await asyncio.sleep(self.interval)
+            try:
+                query = await self.get_conv()
+                if not query:
+                    continue
+                
+                # is wake
+                if query == self.activate_word:
+                    self.entered = True
+                    await self.stop_playing()
+                    await self.send("我来啦！")
+                    continue
+                elif query == self.deactivate_word:
+                    self.entered = False
+                    await self.stop_playing()
+                    await self.send("再见，欢迎给个 Star。")
+                    continue
+                if not self.entered:
+                    continue
+                
+                await self.send("")
+                abm = await self._convert(query)
+                
+                if abm:
+                    coro = getattr(self, "on_event_received")
+                    if coro:
+                        await coro(abm)
+                
+            except BaseException as e:
+                traceback.print_exc()
+                logger.error(e)
+                
+    async def _convert(self, query: str):
+        abm = AstrBotMessage()
+        abm.message = [Plain(query)]
+        abm.message_id = str(int(time.time()))
+        abm.message_str = query
+        abm.raw_message = query
+        abm.session_id = f"{self.hardware}_{self.did}_{self.username}"
+        abm.sender = MessageMember(self.username, "主人")
+        abm.self_id = f"{self.hardware}_{self.did}"
+        abm.type = MessageType.FRIEND_MESSAGE
+        return abm
+    
+    async def send(self, message: str):
+        text = f'5 {message}'
+        await miio_command(self.miio_service, self.did, text, 'astrbot')
+        
+    async def stop_playing(self):
+        text = f'3-2'
+        await miio_command(self.miio_service, self.did, text, 'astrbot')

astrbot/core/platform/sources/mispeaker/miservice/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2022 Yonsm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

astrbot/core/platform/sources/mispeaker/miservice/__init__.py

@@ -0,0 +1,5 @@
+from .miaccount import MiAccount, MiTokenStore
+from .minaservice import MiNAService
+from .miioservice import MiIOService
+from .miiocommand import miio_command, miio_command_help
+

astrbot/core/platform/sources/mispeaker/miservice/miaccount.py

@@ -0,0 +1,135 @@
+import base64
+import hashlib
+import json
+import logging
+import os
+import random
+import string
+from urllib import parse
+from aiohttp import ClientSession
+from aiofiles import open as async_open
+
+_LOGGER = logging.getLogger(__package__)
+
+
+def get_random(length):
+    return ''.join(random.sample(string.ascii_letters + string.digits, length))
+
+
+class MiTokenStore:
+
+    def __init__(self, token_path):
+        self.token_path = token_path
+
+    async def load_token(self):
+        if os.path.isfile(self.token_path):
+            try:
+                async with async_open(self.token_path) as f:                    
+                    return json.loads(await f.read())
+            except Exception as e:
+                _LOGGER.exception("Exception on load token from %s: %s", self.token_path, e)
+        return None
+
+    async def save_token(self, token=None):
+        if token:
+            try:
+                async with async_open(self.token_path, 'w') as f:
+                    await f.write(json.dumps(token, indent=2))
+            except Exception as e:
+                _LOGGER.exception("Exception on save token to %s: %s", self.token_path, e)
+        elif os.path.isfile(self.token_path):
+            os.remove(self.token_path)
+
+
+class MiAccount:
+
+    def __init__(self, session: ClientSession, username, password, token_store='.mi.token'):
+        self.session = session
+        self.username = username
+        self.password = password
+        self.token_store = MiTokenStore(token_store) if isinstance(token_store, str) else token_store
+        self.token = None
+
+    async def login(self, sid):
+        if not self.token:
+            self.token = {'deviceId': get_random(16).upper()}
+        try:
+            resp = await self._serviceLogin(f'serviceLogin?sid={sid}&_json=true')
+            if resp['code'] != 0:
+                data = {
+                    '_json': 'true',
+                    'qs': resp['qs'],
+                    'sid': resp['sid'],
+                    '_sign': resp['_sign'],
+                    'callback': resp['callback'],
+                    'user': self.username,
+                    'hash': hashlib.md5(self.password.encode()).hexdigest().upper()
+                }
+                resp = await self._serviceLogin('serviceLoginAuth2', data)
+                if resp['code'] != 0:
+                    raise Exception(resp)
+
+            self.token['userId'] = resp['userId']
+            self.token['passToken'] = resp['passToken']
+
+            serviceToken = await self._securityTokenService(resp['location'], resp['nonce'], resp['ssecurity'])
+            self.token[sid] = (resp['ssecurity'], serviceToken)
+            if self.token_store:
+                await self.token_store.save_token(self.token)
+            return True
+
+        except Exception as e:
+            self.token = None
+            if self.token_store:
+                await self.token_store.save_token()
+            _LOGGER.exception("Exception on login %s: %s", self.username, e)
+            return False
+
+    async def _serviceLogin(self, uri, data=None):
+        headers = {'User-Agent': 'APP/com.xiaomi.mihome APPV/6.0.103 iosPassportSDK/3.9.0 iOS/14.4 miHSTS'}
+        cookies = {'sdkVersion': '3.9', 'deviceId': self.token['deviceId']}
+        if 'passToken' in self.token:
+            cookies['userId'] = self.token['userId']
+            cookies['passToken'] = self.token['passToken']
+        url = 'https://account.xiaomi.com/pass/' + uri
+        async with self.session.request('GET' if data is None else 'POST', url, data=data, cookies=cookies, headers=headers) as r:
+            raw = await r.read()
+        resp = json.loads(raw[11:])
+        _LOGGER.debug("%s: %s", uri, resp)
+        return resp
+
+    async def _securityTokenService(self, location, nonce, ssecurity):
+        nsec = 'nonce=' + str(nonce) + '&' + ssecurity
+        clientSign = base64.b64encode(hashlib.sha1(nsec.encode()).digest()).decode()
+        async with self.session.get(location + '&clientSign=' + parse.quote(clientSign)) as r:
+            serviceToken = r.cookies['serviceToken'].value
+            if not serviceToken:
+                raise Exception(await r.text())
+        return serviceToken
+
+    async def mi_request(self, sid, url, data, headers, relogin=True):
+        if self.token is None and self.token_store is not None:
+            self.token = await self.token_store.load_token()
+        if (self.token and sid in self.token) or await self.login(sid):  # Ensure login
+            cookies = {'userId': self.token['userId'], 'serviceToken': self.token[sid][1]}
+            content = data(self.token, cookies) if callable(data) else data
+            method = 'GET' if data is None else 'POST'
+            _LOGGER.debug("%s %s", url, content)
+            async with self.session.request(method, url, data=content, cookies=cookies, headers=headers) as r:
+                status = r.status
+                if status == 200:
+                    resp = await r.json(content_type=None)
+                    code = resp['code']
+                    if code == 0:
+                        return resp
+                    if 'auth' in resp.get('message', '').lower():
+                        status = 401
+                else:
+                    resp = await r.text()
+            if status == 401 and relogin:
+                _LOGGER.warn("Auth error on request %s %s, relogin...", url, resp)
+                self.token = None  # Auth error, reset login
+                return await self.mi_request(sid, url, data, headers, False)
+        else:
+            resp = "Login failed"
+        raise Exception(f"Error {url}: {resp}")