libcec pythin

#! /usr/bin/python

import time
import cec
import glob
import re
import os
import logging
from subprocess import call

class EntoneCecClient:
  CEC_KEY_EXIT      = 44
  CEC_KEY_EPG       = 83
  CEC_KEY_OK        = 0
  CEC_KEY_UP        = 1
  CEC_KEY_DOWN      = 2
  CEC_KEY_RIGHT     = 4
  CEC_KEY_LEFT      = 3
  CEC_KEY_OPTION    = 10
  CEC_KEY_BACK      = 13
  CEC_KEY_RED       = 114
  CEC_KEY_GREEN     = 115
  CEC_KEY_YELLOW    = 116
  CEC_KEY_BLUE      = 113
  CEC_KEY_TEXT      = 118
  CEC_KEY_SUBTITLE  = 81
  CEC_KEY_0     = 32
  CEC_KEY_1     = 33
  CEC_KEY_2     = 34
  CEC_KEY_3     = 35
  CEC_KEY_4     = 36
  CEC_KEY_5     = 37
  CEC_KEY_6     = 38
  CEC_KEY_7     = 39
  CEC_KEY_8     = 40
  CEC_KEY_9     = 41
  CEC_KEY_CHANNELUP = 48
  CEC_KEY_CHANNELDOWN   = 49
  CEC_KEY_RECORD    = 71
  CEC_KEY_REWIND    = 76
  CEC_KEY_PLAY      = 68
  CEC_KEY_FORWARD   = 75
  CEC_KEY_STOP      = 69 # Not given back with 0 duration!
  CEC_KEY_PLAYPAUSE = 70

  key_map = {
#           : "KEY_MENU",
#           : "KEY_INFO",
#           : "KEY_VOLUMEUP",
#           : "KEY_VOLUMEDOWN",
#           : "KEY_MUTE",
#           : "KEY_DOT",
#           : "KEY_POWER",
    CEC_KEY_EXIT    : "KEY_EXIT",
    CEC_KEY_EPG     : "KEY_EPG",
    CEC_KEY_OK      : "KEY_OK",
    CEC_KEY_UP      : "KEY_UP",
    CEC_KEY_DOWN    : "KEY_DOWN",
    CEC_KEY_RIGHT   : "KEY_RIGHT",
    CEC_KEY_LEFT    : "KEY_LEFT",
#   CEC_KEY_OPTION  : "",
    CEC_KEY_BACK    : "KEY_BACK",
    CEC_KEY_RED     : "KEY_RED",
    CEC_KEY_GREEN   : "KEY_GREEN",
    CEC_KEY_YELLOW  : "KEY_YELLOW",
    CEC_KEY_BLUE    : "KEY_BLUE",
    CEC_KEY_TEXT    : "KEY_TEXT",
#   CEC_KEY_SUBTITLE: "",
    CEC_KEY_0       : "KEY_0",
    CEC_KEY_1       : "KEY_1",
    CEC_KEY_2       : "KEY_2",
    CEC_KEY_3       : "KEY_3",
    CEC_KEY_4       : "KEY_4",
    CEC_KEY_5       : "KEY_5",
    CEC_KEY_6       : "KEY_6",
    CEC_KEY_7       : "KEY_7",
    CEC_KEY_8       : "KEY_8",
    CEC_KEY_9       : "KEY_9",
    CEC_KEY_CHANNELUP   : "KEY_CHANNELUP",
    CEC_KEY_CHANNELDOWN : "KEY_CHANNELDOWN",
    CEC_KEY_RECORD  : "KEY_RECORD",
#   CEC_KEY_REWIND  : "",
#   CEC_KEY_PLAY    : "",
#   CEC_KEY_FORWARD : "",
    CEC_KEY_STOP    : "KEY_STOP",
    CEC_KEY_PLAYPAUSE   : "KEY_PLAYPAUSE"
  }

  cecconfig = cec.libcec_configuration()
  lib = {}

  # create a new libcec_configuration
  def set_configuration(self):
    self.cecconfig.strDeviceName   = "Entone"
    self.cecconfig.bActivateSource = 0
    self.cecconfig.deviceTypes.Add(cec.CEC_DEVICE_TYPE_RECORDING_DEVICE)
    self.cecconfig.clientVersion = cec.LIBCEC_VERSION_CURRENT

  def set_key_press_callback(self, callback):
    self.cecconfig.set_key_press_callback(callback)

  def set_source_actived_callback(self, callback):
    self.cecconfig.Setsource_activated_callback(callback)

  # detect an USB-CEC adapter and return the com port path
  def detect_adapter(self):
    logger.debug("Detecting adapter")
    retval = None

    # take possible versions/revisions into account
    devices = glob.glob('/dev/serial/by-id/usb-Pulse-Eight_USB-CEC_Adapter*-if00')
    # just use the first device, if any
    if len(devices) > 0:
      retval = os.path.realpath(devices[0])

    return retval

  # initialise libCEC
  def init_libcec(self):
    self.lib = cec.ICECAdapter.Create(self.cecconfig)

    # search for adapters
    adapter = self.detect_adapter()
    if adapter == None:
      logger.error("No USB-CEC adapter found")
    else:
      logger.info("Using USB-CEC adapter: {}".format(adapter))
      if self.lib.Open(adapter):
        logger.info("Connection opened")
        self.main_loop()
      else:
        logger.error("Failed to open connection to USB-CEC adapter")

  # main loop, ask for commands
  def main_loop(self):
    logger.debug("Waiting...")
    runLoop = True

#    while runLoop:
#      command = raw_input("Enter command:").lower()
#      if command == 'q' or command == 'quit':
#        runLoop = False
    while True:
      time.sleep(0.05)
      pass

    logger.info('Exiting...')

  # key press callback
  def key_press_callback(self, key, duration):
    logger.debug("Key pressed")
    logger.debug("[key pressed] {} ({})".format(key, duration))
    # only act on initial key presses (duration 0), including repeats
    # make key CEC_KEY_STOP an exception because it never gives duration 0
    if duration == 0 or key == self.CEC_KEY_STOP:
      self.execute_lirc_command(key)
    return 0

  def source_activated_callback(self, device, state):
    logger.debug("Device {} activated state changed to {}".format(device, bool(state)))

  # Execute LIRC command
  def execute_lirc_command(self, key):
    logger.info("Lets execute: {}".format(self.key_map[key]))
    call(['irsend', 'SEND_ONCE', 'ENTONE_URC-4021ABA1-006-R', self.key_map[key]])

  def __init__(self):
    self.set_configuration()

# key press callback
def key_press_callback(key, duration):
  return lib.key_press_callback(key, duration)

# source activated callback
def source_activated_callback(device, state):
  return lib.source_activated_callback(device, state)

if __name__ == '__main__':
  logging.basicConfig(level=logging.WARNING)
  logger = logging.getLogger(__name__)

  # initialise libCEC
  lib = EntoneCecClient()
  lib.set_key_press_callback(key_press_callback)
  lib.set_source_actived_callback(source_activated_callback)

  # initialise libCEC and enter the main loop
  lib.init_libcec()