Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

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

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

# Licensed under the MIT license 

# http://opensource.org/licenses/mit-license.php 

 

# Copyright 2006, Frank Scholz <coherence@beebits.net> 

 

import coherence.extern.louie as louie 

from coherence import log 

from coherence.upnp.services.clients.av_transport_client import \ 

    AVTransportClient 

from coherence.upnp.services.clients.connection_manager_client import \ 

    ConnectionManagerClient 

from coherence.upnp.services.clients.rendering_control_client import \ 

    RenderingControlClient 

 

 

class MediaRendererClient(log.LogAble): 

    logCategory = 'mr_client' 

 

    def __init__(self, device): 

        log.LogAble.__init__(self) 

        self.device = device 

        self.device_type = self.device.get_friendly_device_type() 

        self.version = int(self.device.get_device_type_version()) 

        self.icons = device.icons 

        self.rendering_control = None 

        self.connection_manager = None 

        self.av_transport = None 

 

        self.detection_completed = False 

 

        louie.connect(self.service_notified, 

                      signal='Coherence.UPnP.DeviceClient.Service.notified', 

                      sender=self.device) 

 

        for service in self.device.get_services(): 

            if service.get_type() in [ 

                    "urn:schemas-upnp-org:service:RenderingControl:1", 

                    "urn:schemas-upnp-org:service:RenderingControl:2"]: 

                self.rendering_control = RenderingControlClient(service) 

            if service.get_type() in [ 

                    "urn:schemas-upnp-org:service:ConnectionManager:1", 

                    "urn:schemas-upnp-org:service:ConnectionManager:2"]: 

                self.connection_manager = ConnectionManagerClient(service) 

            if service.get_type() in [ 

                    "urn:schemas-upnp-org:service:AVTransport:1", 

                    "urn:schemas-upnp-org:service:AVTransport:2"]: 

                self.av_transport = AVTransportClient(service) 

        self.info("MediaRenderer %s", self.device.get_friendly_name()) 

        if self.rendering_control: 

            self.info("RenderingControl available") 

            """ 

            actions =  self.rendering_control.service.get_actions() 

            print actions 

            for action in actions: 

                print "Action:", action 

                for arg in actions[action].get_arguments_list(): 

                    print "       ", arg 

            """ 

            # self.rendering_control.list_presets() 

            # self.rendering_control.get_mute() 

            # self.rendering_control.get_volume() 

            # self.rendering_control.set_mute(desired_mute=1) 

        else: 

            self.warning( 

                "RenderingControl not available, device not implemented" 

                " properly according to the UPnP specification") 

            return 

        if self.connection_manager: 

            self.info("ConnectionManager available") 

            # self.connection_manager.get_protocol_info() 

        else: 

            self.warning( 

                "ConnectionManager not available, device not implemented" 

                " properly according to the UPnP specification") 

            return 

        if self.av_transport: 

            self.info("AVTransport (optional) available") 

            # self.av_transport.service.subscribe_for_variable( 

            #     'LastChange', 0, self.state_variable_change) 

            # self.av_transport.service.subscribe_for_variable( 

            #     'TransportState', 0, self.state_variable_change) 

            # self.av_transport.service.subscribe_for_variable( 

            #     'CurrentTransportActions', 0, self.state_variable_change) 

            # self.av_transport.get_transport_info() 

            # self.av_transport.get_current_transport_actions() 

 

    # def __del__(self): 

    #    #print "MediaRendererClient deleted" 

    #    pass 

 

    def remove(self): 

        self.info("removal of MediaRendererClient started") 

        if self.rendering_control is not None: 

            self.rendering_control.remove() 

        if self.connection_manager is not None: 

            self.connection_manager.remove() 

        if self.av_transport is not None: 

            self.av_transport.remove() 

        # del self 

 

    def service_notified(self, service): 

        self.info("Service %r sent notification", service) 

        if self.detection_completed: 

            return 

        if self.rendering_control is not None: 

            if not hasattr(self.rendering_control.service, 

                           'last_time_updated'): 

                return 

            if self.rendering_control.service.last_time_updated is None: 

                return 

        if self.connection_manager is not None: 

            if not hasattr(self.connection_manager.service, 

                           'last_time_updated'): 

                return 

            if self.connection_manager.service.last_time_updated is None: 

                return 

        if self.av_transport is not None: 

            if not hasattr(self.av_transport.service, 'last_time_updated'): 

                return 

            if self.av_transport.service.last_time_updated is None: 

                return 

        self.detection_completed = True 

        louie.send('Coherence.UPnP.DeviceClient.detection_completed', None, 

                   client=self, udn=self.device.udn) 

 

    def state_variable_change(self, variable): 

        self.info('%(name)r changed from %(old_value)r to %(value)r', 

                  vars(variable))