def Connected(self, monitor = None, useCache = True):
        # Camera test and caching logic
        if monitor:
            if useCache:
                utils.log(2, 'Camera %s :: Checking previous camera test connection result...' %self.camera_number)
                return monitor.testResult(self.camera_number)
                    
            else:
                if self.camera_type != GENERIC_IPCAM:
                    utils.log(2, 'Camera %s :: Testing network connection to camera...' %self.camera_number)

                    success_code, response = self.camera.get_dev_state()
                    monitor.write_testResult(self.camera_number, success_code)
                
                    if success_code != 0:
                        return False
            
                    utils.log(2, 'Camera %s :: Connection successful.' %self.camera_number)

                    # MJPEG Enable - for Service Run.  Ensures MJPEG URLs are Successful  MAYBE MOVE THIS LATER SOMEWHERE??? 
                    if settings.getSetting_int('stream', self.camera_number) == 1 or \
                       settings.getSetting_int('allstream', self.camera_number) != 1 or \
                       settings.getSetting_int('preview_stream', self.camera_number) != 1:
                        self.enable_mjpeg()

                else:
                    # Set result for Generic IP Camera
                    monitor.write_testResult(self.camera_number, 0)

                return True
        return False
    def Connected(self, monitor = None, useCache = True):
        # Camera test and caching logic
        if monitor:
            if useCache:
                utils.log(2, 'Camera %s :: Checking previous camera test connection result...' %self.camera_number)
                return monitor.testResult(self.camera_number)
                    
            else:
                if self.camera_type != GENERIC_IPCAM:
                    utils.log(2, 'Camera %s :: Testing network connection to camera...' %self.camera_number)

                    success_code, response = self.camera.get_dev_state()
                    monitor.write_testResult(self.camera_number, success_code)
                
                    if success_code != 0:
                        return False
            
                    utils.log(2, 'Camera %s :: Connection successful.' %self.camera_number)

                    # MJPEG Enable - for Service Run.  Ensures MJPEG URLs are Successful  MAYBE MOVE THIS LATER SOMEWHERE??? 
                    if settings.getSetting_int('stream', self.camera_number) == 1 or \
                       settings.getSetting_int('allstream', self.camera_number) != 1 or \
                       settings.getSetting_int('preview_stream', self.camera_number) != 1:
                        self.enable_mjpeg()

                else:
                    # Set result for Generic IP Camera
                    monitor.write_testResult(self.camera_number, 0)

                return True
        return False
 def reset(self):
     ''' Reinitializes monitor settings '''
     Window(10000).setProperty('SR_monitor', '1')
     self.dismissed_time = [0, 0, 0, 0, 0, 0, 0]  
     self._dismissed_behavior = settings.getSetting_int('dismissed_behavior')            #0 - All dismissed, 1 - Just the window itself
     self._dismissed_duration = settings.getSetting_int('dismissed_duration') 
     self._preview_disabled_window_id = settings.getDisabledWindowIds()
 def resetLocation(self):
     if settings.getSetting_int('ptz', self.camera_number) > 0:
         reset_mode = settings.getSetting_int('conn', self.camera_number)
         if reset_mode > 0:
             if reset_mode == 2:
                 reset_mode = 3
             self.camera.ptz_home_location(reset_mode)
             utils.log(2, 'Camera %s :: Resetting to the home location' %self.camera_number)
 def resetLocation(self):
     if settings.getSetting_int('ptz', self.camera_number) > 0:
         reset_mode = settings.getSetting_int('conn', self.camera_number)
         if reset_mode > 0:
             if reset_mode == 2:
                 reset_mode = 3
             self.camera.ptz_home_location(reset_mode)
             utils.log(2, 'Camera %s :: Resetting to the home location' %self.camera_number)
    def __init__(self, camera, monitor):
        self.camera = camera
        self.monitor = monitor
        self.cond_service = settings.getSetting_int('cond_service', self.camera.number)
        self.cond_manual = settings.getSetting_int('cond_manual', self.camera.number)
        self.dur_service = settings.getSetting_int('dur_service', self.camera.number)
        self.dur_manual = settings.getSetting_int('dur_manual', self.camera.number)
        self.prefix = 'Preview'
        self.buttons = []
        
        # Positioning of the window       
        WIDTH = 320
        HEIGHT = 180
        
        scaling = settings.getSetting_float('scaling', self.camera.number)
        
        width = int(float(WIDTH * scaling))
        height = int(float(HEIGHT * scaling))
        
        button_scaling = 0.5 * scaling
        button_width = int(round(Button.WIDTH * button_scaling))
        
        position = settings.getSetting('position', self.camera.number).lower()
        if 'bottom' in position:
            y = 720 - height
        else:
            y = 0

        if 'left' in position:
            x = 0
            start = - width
        else:
            x = 1280 - width
            start = width

        animations = [('WindowOpen', ("effect=slide start={0:d} time=1300 tween=cubic easing=out").format(start)),
                      ('WindowClose', ("effect=slide end={0:d} time=900 tween=back easing=inout").format(start))]

        self.black = xbmcgui.ControlImage(x, y, width, height, _black)
        self.addControl(self.black)
        self.black.setAnimations(animations)
        
        self.img1 = xbmcgui.ControlImage(x, y, width, height, '')
        self.img2 = xbmcgui.ControlImage(x, y, width, height, '')
        self.addControl(self.img1)
        self.addControl(self.img2)
        self.img1.setAnimations(animations)
        self.img2.setAnimations(animations)

        self.close_button = Button(self, 'close', x + width - button_width - 10, y + 10, scaling=button_scaling)
        self.addControl(self.close_button)
        self.close_button.setAnimations(animations)                    
           
        self.setProperty('zorder', "99")

        self.playFullscreen = False
        self.stop() #Initializes state and makes ready to be used
Example #7
0
 def reset(self):
     ''' Reinitializes monitor settings '''
     Window(10000).setProperty('SR_monitor', '1')
     self.dismissed_time = [0, 0, 0, 0, 0, 0, 0]
     self._dismissed_behavior = settings.getSetting_int(
         'dismissed_behavior'
     )  #0 - All dismissed, 1 - Just the window itself
     self._dismissed_duration = settings.getSetting_int(
         'dismissed_duration')
     self._preview_disabled_window_id = settings.getDisabledWindowIds()
 def getStreamType(self, source):
     '''
     Source:   0 Video Stream;  1 All Camera Player;  2 Preview
     '''
     
     if source == SINGLE_CAMERA_PLAYER:
         return settings.getSetting_int('stream', self.camera_number)        
     elif source == ALL_CAMERA_PLAYER:
         return settings.getSetting_int('allstream', self.camera_number)
     elif source == PREVIEW_WINDOW:
         return settings.getSetting_int('preview_stream', self.camera_number)
 def getStreamType(self, source):
     '''
     Source:   0 Video Stream;  1 All Camera Player;  2 Preview
     '''
     
     if source == SINGLE_CAMERA_PLAYER:
         return settings.getSetting_int('stream', self.camera_number)        
     elif source == ALL_CAMERA_PLAYER:
         return settings.getSetting_int('allstream', self.camera_number)
     elif source == PREVIEW_WINDOW:
         return settings.getSetting_int('preview_stream', self.camera_number)
    def getTriggerInterval(self, motion_enabled, sound_enabled):
        """ Gets the alarm trigger interval from the camera """
        trigger_interval = settings.getSetting_int('interval',
                                                   self.camera_number)

        if self.camera_type != FOSCAM_SD and \
           self.camera_type != GENERIC_IPCAM:
            try:
                motion_trigger_interval = int(
                    self.camera.get_motion_detect_config()[1]
                    ['triggerInterval'])
                sound_trigger_interval = int(
                    self.camera.get_sound_detect_config()[1]
                    ['triggerInterval'])

                if motion_enabled and sound_enabled:
                    trigger_interval = min(motion_trigger_interval,
                                           sound_trigger_interval)
                elif motion_enabled:
                    trigger_interval = motion_trigger_interval
                elif sound_enabled:
                    trigger_interval = sound_trigger_interval

            except:
                pass

        return trigger_interval
    def getTriggerInterval(self, motion_enabled, sound_enabled):
        """ Gets the alarm trigger interval from the camera """
        trigger_interval = settings.getSetting_int('interval', self.camera_number)

        if self.camera_type != FOSCAM_SD and \
           self.camera_type != GENERIC_IPCAM:
            try:
                motion_trigger_interval = int(self.camera.get_motion_detect_config()[1]['triggerInterval'])
                sound_trigger_interval = int(self.camera.get_sound_detect_config()[1]['triggerInterval'])
            
                if motion_enabled and sound_enabled:    trigger_interval = min(motion_trigger_interval, sound_trigger_interval)    
                elif motion_enabled:                    trigger_interval = motion_trigger_interval  
                elif sound_enabled:                     trigger_interval = sound_trigger_interval
                
            except:
                pass
            
        return trigger_interval
    def maybe_resume_previous(self):
        """ If a video was playing previously, it will restart it at the resume time """
        if settings.getSetting_bool('resume'):
            try:
                previous_file = Window(10000).getProperty('SR_previousFile')
            except:
                previous_file = ''
                
            if previous_file != '':
                resume_time = float(Window(10000).getProperty('SR_resumeTime'))
                Window(10000).clearProperty('SR_resumeTime')
                Window(10000).clearProperty('SR_previousFile')
                
                resume_time_adjustment = settings.getSetting_int('resume_time')
                resume_time_str = "{0:.1f}".format(resume_time - resume_time_adjustment)
                listitem = ListItem()
                listitem.setProperty('StartOffset', resume_time_str)

                player = xbmc.Player()  
                player.play(previous_file, listitem)
Example #13
0
    def stop(self, playFullscreen=False):
        self.monitor.closePreview(self.camera.number)
        self.close()
        utils.log(2, 'Camera %s :: Preview Window Closed' % self.camera.number)

        if not self.monitor.abortRequested() and not self.monitor.stopped():

            if playFullscreen:
                self.monitor.maybe_stop_current()
                fullscreenplayer = settings.getSetting_int('fullscreen_player')

                if fullscreenplayer == CAMERAWITHCONTROLS:
                    cameraplayer.play(self.camera.number)

                elif fullscreenplayer == CAMERAWITHOUTCONTROLS:
                    cameraplayer.play(self.camera.number, show_controls=False)

                elif fullscreenplayer == ALLCAMERAPLAYER:
                    allcameraplayer.play()

            self.wait_openRequest()
    def stop(self, playFullscreen = False):
        self.monitor.closePreview(self.camera.number)
        self.close()
        utils.log(2, 'Camera %s :: Preview Window Closed' %self.camera.number)
        
        if not self.monitor.abortRequested() and not self.monitor.stopped():

            if playFullscreen:
                self.monitor.maybe_stop_current()
                fullscreenplayer = settings.getSetting_int('fullscreen_player')

                if fullscreenplayer == CAMERAWITHCONTROLS:
                    cameraplayer.play(self.camera.number)
                    
                elif fullscreenplayer == CAMERAWITHOUTCONTROLS:
                    cameraplayer.play(self.camera.number, show_controls = False)
                
                elif fullscreenplayer == ALLCAMERAPLAYER:
                    allcameraplayer.play()
                
            self.wait_openRequest()
Example #15
0
    def maybe_resume_previous(self):
        """ If a video was playing previously, it will restart it at the resume time """
        if settings.getSetting_bool('resume'):
            try:
                previous_file = Window(10000).getProperty('SR_previousFile')
            except:
                previous_file = ''

            if previous_file != '':
                resume_time = float(Window(10000).getProperty('SR_resumeTime'))
                Window(10000).clearProperty('SR_resumeTime')
                Window(10000).clearProperty('SR_previousFile')

                resume_time_adjustment = settings.getSetting_int('resume_time')
                resume_time_str = "{0:.1f}".format(resume_time -
                                                   resume_time_adjustment)
                listitem = ListItem()
                listitem.setProperty('StartOffset', resume_time_str)

                player = xbmc.Player()
                player.play(previous_file, listitem)
Example #16
0
    def setupUi(self):
        response_code, response = self.camera.get_mirror_and_flip_setting()
        if response_code == 0:

            # Button Placement settings
            Y_OFFSET = 100
            X_OFFSET = 20
            OFFSET1 = 32
            OFFSET2 = 64

            self.buttons = []

            # Default Foscam Buttons
            self.flip_button = ToggleButton(self, 'flip', 30, Y_OFFSET + 200)
            self.mirror_button = ToggleButton(self, 'mirror', 30,
                                              Y_OFFSET + 260)
            self.close_button = Button(self, 'close', 1280 - 60, 20)
            self.addon_settings_button = Button(self, 'addon_settings',
                                                1280 - 120, 20)
            self.camera_settings_button = Button(self, 'camera_settings',
                                                 1280 - 180, 20)

            self.addControl(self.addon_settings_button)
            self.addControl(self.camera_settings_button)
            self.addControl(self.close_button)
            self.addControl(self.flip_button)
            self.addControl(self.mirror_button)

            self.mirror_button.setSelected(int(response['isMirror']))
            self.flip_button.setSelected(int(response['isFlip']))

            self.flip_button.setNavigation(self.camera_settings_button,
                                           self.mirror_button,
                                           self.close_button,
                                           self.camera_settings_button)
            self.mirror_button.setNavigation(self.flip_button,
                                             self.close_button,
                                             self.close_button,
                                             self.camera_settings_button)
            self.addon_settings_button.setNavigation(
                self.mirror_button, self.flip_button,
                self.camera_settings_button, self.close_button)
            self.camera_settings_button.setNavigation(
                self.mirror_button, self.flip_button, self.flip_button,
                self.addon_settings_button)
            self.close_button.setNavigation(self.mirror_button,
                                            self.flip_button,
                                            self.addon_settings_button,
                                            self.flip_button)

            # PTZ Buttons
            ptz = settings.getSetting_int('ptz', self.camera.number)

            self.pan_tilt = False
            if ptz > 0:
                self.pan_tilt = True
                self.sensitivity = self.camera.ptz_sensitivity

            self.zoom = False
            if ptz > 1:
                self.zoom = True

            if self.pan_tilt:

                self.up_button = Button(self, 'up', OFFSET1 + X_OFFSET,
                                        Y_OFFSET)
                self.left_button = Button(self, 'left', X_OFFSET,
                                          OFFSET1 + Y_OFFSET)
                self.down_button = Button(self, 'down', OFFSET1 + X_OFFSET,
                                          OFFSET2 + Y_OFFSET)
                self.right_button = Button(self, 'right', OFFSET2 + X_OFFSET,
                                           OFFSET1 + Y_OFFSET)
                self.top_left_button = Button(self, 'top_left', X_OFFSET,
                                              Y_OFFSET)
                self.top_right_button = Button(self, 'top_right',
                                               OFFSET2 + X_OFFSET, Y_OFFSET)
                self.bottom_right_button = Button(self, 'bottom_right',
                                                  OFFSET2 + X_OFFSET,
                                                  OFFSET2 + Y_OFFSET)
                self.bottom_left_button = Button(self, 'bottom_left', X_OFFSET,
                                                 OFFSET2 + Y_OFFSET)
                self.home_button = Button(self, 'home', OFFSET1 + X_OFFSET,
                                          OFFSET1 + Y_OFFSET)
                self.preset_button = ToggleButton(self, 'preset', 30,
                                                  Y_OFFSET + 320)

                self.addControl(self.up_button)
                self.addControl(self.left_button)
                self.addControl(self.down_button)
                self.addControl(self.right_button)
                self.addControl(self.top_left_button)
                self.addControl(self.top_right_button)
                self.addControl(self.bottom_right_button)
                self.addControl(self.bottom_left_button)
                self.addControl(self.home_button)
                self.addControl(self.preset_button)

                self.flip_button.setNavigation(self.down_button,
                                               self.mirror_button,
                                               self.close_button,
                                               self.camera_settings_button)
                self.mirror_button.setNavigation(self.flip_button,
                                                 self.preset_button,
                                                 self.close_button,
                                                 self.camera_settings_button)
                self.preset_button.setNavigation(self.mirror_button,
                                                 self.up_button,
                                                 self.close_button,
                                                 self.camera_settings_button)
                self.addon_settings_button.setNavigation(
                    self.preset_button, self.preset_button,
                    self.camera_settings_button, self.close_button)
                self.camera_settings_button.setNavigation(
                    self.preset_button, self.preset_button, self.right_button,
                    self.addon_settings_button)
                self.close_button.setNavigation(self.preset_button,
                                                self.preset_button,
                                                self.addon_settings_button,
                                                self.left_button)
                self.up_button.setNavigation(self.preset_button,
                                             self.home_button,
                                             self.top_left_button,
                                             self.top_right_button)
                self.left_button.setNavigation(self.top_left_button,
                                               self.bottom_left_button,
                                               self.close_button,
                                               self.home_button)
                self.right_button.setNavigation(self.top_right_button,
                                                self.bottom_right_button,
                                                self.home_button,
                                                self.camera_settings_button)
                self.down_button.setNavigation(self.home_button,
                                               self.flip_button,
                                               self.bottom_left_button,
                                               self.bottom_right_button)
                self.top_left_button.setNavigation(self.preset_button,
                                                   self.left_button,
                                                   self.close_button,
                                                   self.up_button)
                self.top_right_button.setNavigation(
                    self.preset_button, self.right_button, self.up_button,
                    self.camera_settings_button)
                self.bottom_right_button.setNavigation(
                    self.right_button, self.flip_button, self.down_button,
                    self.camera_settings_button)
                self.bottom_left_button.setNavigation(self.left_button,
                                                      self.flip_button,
                                                      self.close_button,
                                                      self.down_button)
                self.home_button.setNavigation(self.up_button,
                                               self.down_button,
                                               self.left_button,
                                               self.right_button)

                # Work Around until Full API is implemented
                if not self.camera._type == FOSCAM_SD:
                    home_location = self.camera.ptz_home_location(0)
                    self.preset_button.setSelected(home_location)

            if self.zoom:
                self.zoom_in_button = Button(self, 'zoom_in',
                                             OFFSET2 + X_OFFSET + 32, Y_OFFSET)
                self.zoom_out_button = Button(self, 'zoom_out',
                                              OFFSET2 + X_OFFSET + 32,
                                              OFFSET2 + Y_OFFSET)
                self.addControl(self.zoom_in_button)
                self.addControl(self.zoom_out_button)

                # Navigation still requires to be set #

            # Work Around until Full API is implemented
            if self.camera._type == FOSCAM_SD:
                self.preset_button.setEnabled(False)
                self.camera_settings_button.setEnabled(False)
                self.home_button.setEnabled(False)

            self.setFocus(self.close_button)
            self.setFocus(
                self.close_button)  #Set twice as sometimes it doesnt set?
    def __init__(self, camera_number, title="Camera Settings"):

        title = "Camera Settings"

        self.x = 340
        self.y = 150
        width = 540
        height = 400

        self.ROW_START = 45
        self.ROW_HEIGHT = 30
        self.X_SHIFT = 10
        self.LABEL_WIDTH = 240

        self.camera = Camera(camera_number)

        self.label_enabled = {0: "Disabled", 1: "Enabled"}

        self.label_interval = {
            5: "5 seconds",
            6: "6 seconds",
            7: "7 seconds",
            8: "8 seconds",
            9: "9 seconds",
            10: "10 seconds",
            11: "11 seconds",
            12: "12 seconds",
            13: "13 seconds",
            14: "14 seconds",
            15: "15 seconds",
        }

        self.label_sensitivity = {0: "Low", 1: "Medium", 2: "High", 3: "Lower", 4: "Lowest"}

        # Draw the window controls
        self._place_window(width, height, title)
        self.place_irconfig(0)
        self.place_pt_speedconfig(1)
        self.place_z_speedconfig(2)
        self.get_motion_default()
        self.place_motion_enable(3)
        self.place_motion_sensitivityconfig(4)
        self.place_motion_triggerconfig(5)
        self.get_sound_default()
        self.place_sound_enable(6)
        self.place_sound_sensitivityconfig(7)
        self.place_sound_triggerconfig(8)
        self.place_mjpeg_enable(9)
        self.place_close_button(10)

        # Set up/down navigation
        self.window_close_button.controlDown(self.radio_irAuto)
        self.radio_irAuto.controlUp(self.window_close_button)
        self.radio_irOn.controlUp(self.window_close_button)
        self.radio_irOff.controlUp(self.window_close_button)
        self.radio_irAuto.controlDown(self.button_pt_speedup)
        self.radio_irOn.controlDown(self.button_pt_speeddown)
        self.radio_irOff.controlDown(self.button_pt_speeddown)
        self.button_pt_speedup.controlUp(self.radio_irAuto)
        self.button_pt_speeddown.controlUp(self.radio_irOff)
        self.button_pt_speedup.controlDown(self.button_z_speedup)
        self.button_pt_speeddown.controlDown(self.button_z_speeddown)
        self.button_z_speedup.controlUp(self.button_pt_speedup)
        self.button_z_speeddown.controlUp(self.button_pt_speeddown)
        self.button_z_speedup.controlDown(self.radio_motion)
        self.button_z_speeddown.controlDown(self.radio_motion)
        self.radio_motion.controlUp(self.button_z_speedup)
        self.radio_motion.controlDown(self.button_m_sensitivityup)
        self.button_m_sensitivityup.controlUp(self.radio_motion)
        self.button_m_sensitivitydown.controlUp(self.radio_motion)
        self.button_m_sensitivityup.controlDown(self.button_m_triggerup)
        self.button_m_sensitivitydown.controlDown(self.button_m_triggerup)
        self.button_m_triggerup.controlUp(self.button_m_sensitivityup)
        self.button_m_triggerdown.controlUp(self.button_m_sensitivitydown)
        self.button_m_triggerup.controlDown(self.radio_sound)
        self.button_m_triggerdown.controlDown(self.radio_sound)
        self.radio_sound.controlUp(self.button_m_triggerup)
        self.radio_sound.controlDown(self.button_s_sensitivityup)
        self.button_s_sensitivityup.controlUp(self.radio_sound)
        self.button_s_sensitivitydown.controlUp(self.radio_sound)
        self.button_s_sensitivityup.controlDown(self.button_s_triggerup)
        self.button_s_sensitivitydown.controlDown(self.button_s_triggerdown)
        self.button_s_triggerup.controlUp(self.button_s_sensitivityup)
        self.button_s_triggerdown.controlUp(self.button_s_sensitivitydown)
        self.button_s_triggerup.controlDown(self.radio_mjpeg)
        self.button_s_triggerdown.controlDown(self.radio_h264)
        self.radio_mjpeg.controlUp(self.button_s_triggerup)
        self.radio_h264.controlUp(self.button_s_triggerdown)
        self.radio_mjpeg.controlDown(self.button_close)
        self.radio_h264.controlDown(self.button_close)
        self.button_close.controlUp(self.radio_mjpeg)

        # Disable unsupported features
        ptz = settings.getSetting_int("ptz", self.camera.number)
        if ptz == 0:  # Disable Pan & Tilt
            self.label_pt.setEnabled(False)
            self.button_pt_speedup.setEnabled(False)
            self.button_pt_speeddown.setEnabled(False)
            self.label_pt_speedsetting.setEnabled(False)

        if ptz < 2:  # Disable Zoom:
            self.label_z.setEnabled(False)
            self.button_z_speedup.setEnabled(False)
            self.button_z_speeddown.setEnabled(False)
            self.label_z_speedsetting.setEnabled(False)

        motion_enabled, sound_enabled = settings.getEnabledAlarms(self.camera.number)
        if not motion_enabled:
            self.label_m.setEnabled(False)
            self.label_ms.setEnabled(False)
            self.label_mt.setEnabled(False)
            self.radio_motion.setEnabled(False)
            self.button_m_triggerup.setEnabled(False)
            self.button_m_triggerdown.setEnabled(False)
            self.label_m_triggersetting.setEnabled(False)
            self.button_m_sensitivityup.setEnabled(False)
            self.button_m_sensitivitydown.setEnabled(False)
            self.label_m_sensitivitysetting.setEnabled(False)

        if not sound_enabled:
            self.label_s.setEnabled(False)
            self.label_ss.setEnabled(False)
            self.label_st.setEnabled(False)
            self.radio_sound.setEnabled(False)
            self.button_s_triggerup.setEnabled(False)
            self.button_s_triggerdown.setEnabled(False)
            self.label_s_triggersetting.setEnabled(False)
            self.button_s_sensitivityup.setEnabled(False)
            self.button_s_sensitivitydown.setEnabled(False)
            self.label_s_sensitivitysetting.setEnabled(False)

        self.setFocus(self.radio_irAuto)
"""
plugin.video.surveillanceroom

A Kodi add-on by Maikito26

This module is used to draw and show the preview window
"""

import xbmc, xbmcaddon, xbmcgui, xbmcvfs
import os, requests, time
import utils, settings, cameraplayer, allcameraplayer, monitor
from urllib import urlretrieve
import threading
import socket
TIMEOUT = settings.getSetting_int('request_timeout')
socket.setdefaulttimeout(TIMEOUT)

__addon__ = xbmcaddon.Addon()
__addonid__ = __addon__.getAddonInfo('id')

_black = xbmc.translatePath('special://home/addons/%s/resources/media/black.png' %__addonid__ ).decode('utf-8')
_btnimage = xbmc.translatePath('special://home/addons/%s/resources/media/{0}.png' %__addonid__ ).decode('utf-8')
_error = xbmc.translatePath('special://home/addons/%s/resources/media/error.png' %__addonid__ ).decode('utf-8')
_datapath = xbmc.translatePath('special://profile/addon_data/%s' %__addonid__ ).decode('utf-8')

ACTION_PREVIOUS_MENU = 10
ACTION_BACKSPACE = 110
ACTION_NAV_BACK = 92
ACTION_STOP = 13
ACTION_SELECT_ITEM = 7
Example #19
0
    def __init__(self, camera, monitor):
        self.camera = camera
        self.monitor = monitor
        self.cond_service = settings.getSetting_int('cond_service',
                                                    self.camera.number)
        self.cond_manual = settings.getSetting_int('cond_manual',
                                                   self.camera.number)
        self.dur_service = settings.getSetting_int('dur_service',
                                                   self.camera.number)
        self.dur_manual = settings.getSetting_int('dur_manual',
                                                  self.camera.number)
        self.prefix = 'Preview'
        self.buttons = []

        # Positioning of the window
        WIDTH = 320
        HEIGHT = 180

        scaling = settings.getSetting_float('scaling', self.camera.number)

        width = int(float(WIDTH * scaling))
        height = int(float(HEIGHT * scaling))

        button_scaling = 0.5 * scaling
        button_width = int(round(Button.WIDTH * button_scaling))

        position = settings.getSetting('position', self.camera.number).lower()
        if 'bottom' in position:
            y = 720 - height
        else:
            y = 0

        if 'left' in position:
            x = 0
            start = -width
        else:
            x = 1280 - width
            start = width

        animations = [
            ('WindowOpen',
             ("effect=slide start={0:d} time=1300 tween=cubic easing=out"
              ).format(start)),
            ('WindowClose',
             ("effect=slide end={0:d} time=900 tween=back easing=inout"
              ).format(start))
        ]

        self.black = xbmcgui.ControlImage(x, y, width, height, _black)
        self.addControl(self.black)
        self.black.setAnimations(animations)

        self.img1 = xbmcgui.ControlImage(x, y, width, height, '')
        self.img2 = xbmcgui.ControlImage(x, y, width, height, '')
        self.addControl(self.img1)
        self.addControl(self.img2)
        self.img1.setAnimations(animations)
        self.img2.setAnimations(animations)

        self.close_button = Button(self,
                                   'close',
                                   x + width - button_width - 10,
                                   y + 10,
                                   scaling=button_scaling)
        self.addControl(self.close_button)
        self.close_button.setAnimations(animations)

        self.setProperty('zorder', "99")

        self.playFullscreen = False
        self.stop()  #Initializes state and makes ready to be used
Example #20
0
"""
plugin.video.surveillanceroom

A Kodi add-on by Maikito26

This module is used to draw and show the preview window
"""

import xbmc, xbmcaddon, xbmcgui, xbmcvfs
import os, requests, time
import utils, settings, cameraplayer, allcameraplayer, monitor
from urllib import urlretrieve
import threading
import socket
TIMEOUT = settings.getSetting_int('request_timeout')
socket.setdefaulttimeout(TIMEOUT)

__addon__ = xbmcaddon.Addon()
__addonid__ = __addon__.getAddonInfo('id')

_black = xbmc.translatePath(
    'special://home/addons/%s/resources/media/black.png' %
    __addonid__).decode('utf-8')
_btnimage = xbmc.translatePath(
    'special://home/addons/%s/resources/media/{0}.png' %
    __addonid__).decode('utf-8')
_error = xbmc.translatePath(
    'special://home/addons/%s/resources/media/error.png' %
    __addonid__).decode('utf-8')
_datapath = xbmc.translatePath('special://profile/addon_data/%s' %
                               __addonid__).decode('utf-8')
    def setupUi(self):
        response_code, response = self.camera.get_mirror_and_flip_setting()
        if response_code == 0:

            # Button Placement settings
            Y_OFFSET    = 100
            X_OFFSET    = 20
            OFFSET1     = 32
            OFFSET2     = 64

            self.buttons = []
            
            # Default Foscam Buttons
            self.flip_button        = ToggleButton(self, 'flip', 30, Y_OFFSET+200)        
            self.mirror_button      = ToggleButton(self, 'mirror', 30, Y_OFFSET+260)  
            self.close_button       = Button(self, 'close', 1280-60, 20)       
            self.addon_settings_button      = Button(self, 'addon_settings', 1280-120, 20)
            self.camera_settings_button     = Button(self, 'camera_settings', 1280-180, 20)
            
            self.addControl(self.addon_settings_button)
            self.addControl(self.camera_settings_button)
            self.addControl(self.close_button)
            self.addControl(self.flip_button)
            self.addControl(self.mirror_button)
            
            self.mirror_button.setSelected(int(response['isMirror']))
            self.flip_button.setSelected(int(response['isFlip']))
            
            self.flip_button.setNavigation(self.camera_settings_button, self.mirror_button, self.close_button, self.camera_settings_button)
            self.mirror_button.setNavigation(self.flip_button, self.close_button, self.close_button, self.camera_settings_button)
            self.addon_settings_button.setNavigation(self.mirror_button, self.flip_button, self.camera_settings_button, self.close_button)
            self.camera_settings_button.setNavigation(self.mirror_button, self.flip_button, self.flip_button, self.addon_settings_button)
            self.close_button.setNavigation (self.mirror_button, self.flip_button, self.addon_settings_button, self.flip_button)

            # PTZ Buttons
            ptz = settings.getSetting_int('ptz', self.camera.number)
            
            self.pan_tilt = False
            if ptz > 0: 
                self.pan_tilt = True
                self.sensitivity = self.camera.ptz_sensitivity

            self.zoom = False
            if ptz > 1:
                self.zoom = True
                
            if self.pan_tilt:
                
                self.up_button          = Button(self, 'up', OFFSET1+X_OFFSET, Y_OFFSET)
                self.left_button        = Button(self, 'left', X_OFFSET, OFFSET1+Y_OFFSET)        
                self.down_button        = Button(self, 'down', OFFSET1+X_OFFSET, OFFSET2+Y_OFFSET)    
                self.right_button       = Button(self, 'right', OFFSET2+X_OFFSET, OFFSET1+Y_OFFSET)
                self.top_left_button        = Button(self, 'top_left', X_OFFSET, Y_OFFSET)
                self.top_right_button       = Button(self, 'top_right', OFFSET2+X_OFFSET, Y_OFFSET)
                self.bottom_right_button    = Button(self, 'bottom_right', OFFSET2+X_OFFSET, OFFSET2+Y_OFFSET)
                self.bottom_left_button     = Button(self, 'bottom_left', X_OFFSET, OFFSET2+Y_OFFSET)
                self.home_button        = Button(self, 'home', OFFSET1+X_OFFSET, OFFSET1+Y_OFFSET)
                self.preset_button      = ToggleButton(self, 'preset', 30, Y_OFFSET+320)
                
                self.addControl(self.up_button)
                self.addControl(self.left_button)
                self.addControl(self.down_button)
                self.addControl(self.right_button)
                self.addControl(self.top_left_button)
                self.addControl(self.top_right_button)
                self.addControl(self.bottom_right_button)
                self.addControl(self.bottom_left_button)
                self.addControl(self.home_button)
                self.addControl(self.preset_button)
                
                self.flip_button.setNavigation(self.down_button, self.mirror_button, self.close_button, self.camera_settings_button)
                self.mirror_button.setNavigation(self.flip_button, self.preset_button, self.close_button, self.camera_settings_button)
                self.preset_button.setNavigation(self.mirror_button, self.up_button, self.close_button, self.camera_settings_button)
                self.addon_settings_button.setNavigation(self.preset_button, self.preset_button, self.camera_settings_button, self.close_button)
                self.camera_settings_button.setNavigation(self.preset_button, self.preset_button, self.right_button, self.addon_settings_button)
                self.close_button.setNavigation(self.preset_button, self.preset_button, self.addon_settings_button, self.left_button)
                self.up_button.setNavigation(self.preset_button, self.home_button, self.top_left_button, self.top_right_button)
                self.left_button.setNavigation(self.top_left_button, self.bottom_left_button, self.close_button, self.home_button)
                self.right_button.setNavigation(self.top_right_button, self.bottom_right_button, self.home_button, self.camera_settings_button)
                self.down_button.setNavigation(self.home_button, self.flip_button, self.bottom_left_button, self.bottom_right_button)
                self.top_left_button.setNavigation(self.preset_button, self.left_button, self.close_button, self.up_button)
                self.top_right_button.setNavigation(self.preset_button, self.right_button, self.up_button, self.camera_settings_button)
                self.bottom_right_button.setNavigation(self.right_button, self.flip_button, self.down_button, self.camera_settings_button)
                self.bottom_left_button.setNavigation(self.left_button, self.flip_button, self.close_button, self.down_button)
                self.home_button.setNavigation(self.up_button, self.down_button, self.left_button, self.right_button)

                # Work Around until Full API is implemented
                if not self.camera._type == FOSCAM_SD:
                    home_location = self.camera.ptz_home_location(0)
                    self.preset_button.setSelected(home_location)

            if self.zoom:
                self.zoom_in_button = Button(self, 'zoom_in', OFFSET2+X_OFFSET+32, Y_OFFSET)
                self.zoom_out_button = Button(self, 'zoom_out', OFFSET2+X_OFFSET+32, OFFSET2+Y_OFFSET)
                self.addControl(self.zoom_in_button)
                self.addControl(self.zoom_out_button)

                # Navigation still requires to be set #

            # Work Around until Full API is implemented
            if self.camera._type == FOSCAM_SD:
                self.preset_button.setEnabled(False)
                self.camera_settings_button.setEnabled(False)
                self.home_button.setEnabled(False)
                
            
            self.setFocus(self.close_button)
            self.setFocus(self.close_button)    #Set twice as sometimes it doesnt set?
Example #22
0
"""
plugin.video.surveillanceroom

A Kodi add-on by Maikito26

Module which controls how a single IP camera plays fullscreen
"""

import xbmc, xbmcgui, xbmcaddon
import os
import settings, utils, camerasettings, monitor
from resources.lib.ipcam_api_wrapper import CameraAPIWrapper as Camera
from resources.lib.ipcam_api_wrapper import GENERIC_IPCAM, FOSCAM_SD
import socket
socket.setdefaulttimeout(settings.getSetting_int('request_timeout'))

__addon__ = xbmcaddon.Addon()
__addonid__ = __addon__.getAddonInfo('id')
__path__ = __addon__.getAddonInfo('path')

_btnimage = xbmc.translatePath(
    'special://home/addons/%s/resources/media/{0}.png' %
    __addonid__).decode('utf-8')

monitor = monitor.AddonMonitor()

# Kodi key action codes.
ACTION_PREVIOUS_MENU = 10
ACTION_NAV_BACK = 92
ACTION_BACKSPACE = 110
ACTION_STOP = 13
"""
plugin.video.surveillanceroom

A Kodi add-on by Maikito26

This module is used to show all cameras on fullscreen
"""

import xbmc, xbmcaddon, xbmcvfs, xbmcgui
import threading, os, requests  # , time
from urllib import urlretrieve
import settings, monitor, utils
from resources.lib.ipcam_api_wrapper import CameraAPIWrapper as Camera
import socket

TIMEOUT = settings.getSetting_int("request_timeout")
socket.setdefaulttimeout(TIMEOUT)

__addon__ = xbmcaddon.Addon()
__addonid__ = __addon__.getAddonInfo("id")

_datapath = xbmc.translatePath(("special://profile/addon_data/{0}").format(__addonid__)).decode("utf-8")
_loader = xbmc.translatePath(("special://home/addons/{0}/resources/media/loader_old.gif").format(__addonid__)).decode(
    "utf-8"
)
_error = xbmc.translatePath(("special://home/addons/{0}/resources/media/error.png").format(__addonid__)).decode("utf-8")
_holder = xbmc.translatePath(("special://home/addons/{0}/resources/media/placeholder.jpg").format(__addonid__)).decode(
    "utf-8"
)
_black = xbmc.translatePath("special://home/addons/%s/resources/media/black.png" % __addonid__).decode("utf-8")
"""
plugin.video.surveillanceroom

A Kodi add-on by Maikito26

Module which controls how a single IP camera plays fullscreen
"""

import xbmc, xbmcgui, xbmcaddon
import os
import settings, utils, camerasettings, monitor
from resources.lib.ipcam_api_wrapper import CameraAPIWrapper as Camera
from resources.lib.ipcam_api_wrapper import GENERIC_IPCAM, FOSCAM_SD
import socket
socket.setdefaulttimeout(settings.getSetting_int('request_timeout'))

__addon__ = xbmcaddon.Addon()
__addonid__ = __addon__.getAddonInfo('id')
__path__ = __addon__.getAddonInfo('path')

_btnimage = xbmc.translatePath('special://home/addons/%s/resources/media/{0}.png' %__addonid__ ).decode('utf-8')

monitor = monitor.AddonMonitor()

# Kodi key action codes.
ACTION_PREVIOUS_MENU = 10
ACTION_NAV_BACK = 92
ACTION_BACKSPACE = 110
ACTION_STOP = 13
ACTION_SELECT_ITEM = 7