中介模式(python实现2)

相较前一个中介模式(python实现)来说，本例子实现了多个中介者的情况

from abc import ABCMeta, abstractmethod
from enum import Enum


class InteractiveObject:
    """进行交互的对象"""


class InteractiveObjectImplA:
    """实现类A"""


class InteractiveObjectImplB:
    """实现类B"""


class Mediator:
    """中介类"""

    def __init__(self):
        self.__interactive_obj_a = InteractiveObjectImplA()
        self.__interactive_obj_b = InteractiveObjectImplB()

    def interactive(self):
        """进行交互的操作"""
        # 通过self.__interactive_obj_a和self.__interactive_obj_b完成相应的交互操作


class DeviceType(Enum):
    """设备类型"""
    TypeSpeaker = 1
    TypeMicrophone = 2
    TypeCamera = 3


class DeviceItem:
    """设备项"""

    def __init__(self, id, name, type, is_default=False):
        self.__id = id
        self.__name = name
        self.__type = type
        self.__is_default = is_default

    def __str__(self):
        template = 'type: {} id: {} name: {} is_default: {}.'
        return template.format(self.__id,
                               self.__name,
                               self.__type,
                               self.__is_default)

    def get_id(self):
        return self.__id

    def get_name(self):
        return self.__name

    def get_type(self):
        return self.__type

    def is_default(self):
        return self.__is_default


class DeviceList:
    """设备列表"""

    def __init__(self):
        self.__devices = []

    def add(self, device_item):
        self.__devices.append(device_item)

    def get_count(self):
        return len(self.__devices)

    def get_by_idx(self, idx):
        """通过设备列表的id获取设备"""
        if idx < 0 or idx >= self.get_count():
            return None
        return self.__devices[idx]

    def get_by_id(self, id):
        """通过设备项的id匹配获取设备"""
        for item in self.__devices:
            if item.get_id() == id:
                return item
        return None


class DeviceMgr(metaclass=ABCMeta):

    @abstractmethod
    def enumerate(self):
        """枚举设备列表(在程序初始化时，有设备插拔时都要重新获取设备列表)"""

    @abstractmethod
    def active(self, device_id):
        """选择要使用的设备"""

    @abstractmethod
    def get_cur_device_id(self):
        """获取当前正在使用的设备id"""


class SpeakerMgr(DeviceMgr):
    """扬声器设备管理类"""

    def __init__(self):
        self.__cur_device_id = None

    def enumerate(self):
        """枚举设备列表(真实的项目应该通过驱动程序去读取设备信息，这里只用初始化来模拟)"""
        devices = DeviceList()
        devices.add(DeviceItem('369dd760', 'Realtek', DeviceType.TypeSpeaker))
        devices.add(DeviceItem('59357639', 'NVIDIA', DeviceType.TypeSpeaker, True))
        return devices

    def active(self, device_id):
        """激活指定的设备作为当前要用的设备"""
        self.__cur_device_id = device_id

    def get_cur_device_id(self):
        return self.__cur_device_id


class DeviceUtil:
    """设备工具类"""

    def __init__(self):
        self.__mgrs = {DeviceType.TypeSpeaker: SpeakerMgr()}
        # self.__microphone_mgr = MicrophoneMgr()
        # self.__camera_mgr = CameraMgr()

    def __get_device_mgr(self, type):
        return self.__mgrs[type]

    def get_device_list(self, type):
        return self.__get_device_mgr(type).enumerate()

    def active(self, type, device_id):
        self.__get_device_mgr(type).active(device_id)

    def get_cur_device_id(self, type):
        return self.__get_device_mgr(type).get_cur_device_id()


def test_devices():
    device_util = DeviceUtil()
    device_list = device_util.get_device_list(DeviceType.TypeSpeaker)
    print('麦克风设备列表')
    if device_list.get_count() > 0:
        # 设置第一个设备为要用的设备
        device_util.active(DeviceType.TypeSpeaker,
                           device_list.get_by_idx(0).get_id())
    for idx in range(device_list.get_count()):
        device = device_list.get_by_idx(idx)
        print(device)
    print('当前使用的设备：' + device_list.get_by_id(device_util.get_cur_device_id(DeviceType.TypeSpeaker)).get_name())

    
if __name__ == '__main__':
    test_devices()