def __init__(self, parent, appstyle, clientpanel):
"""Constructor. Create a smartcard and reader tree control on the
left-hand side of the application main frame.
@param parent: the tree panel parent
@param appstyle: a combination of the following styles (bitwise or |)
- TR_SMARTCARD: display a smartcard tree panel
- TR_READER: display a reader tree panel
- default is TR_DEFAULT = TR_SMARTCARD
@param clientpanel: the client panel to notify of smartcard and reader events
"""
wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
sizer = wx.BoxSizer(wx.VERTICAL)
# create the smartcard tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_SMARTCARD:
self.cardtreectrl = CardTreeCtrl(self, clientpanel=clientpanel)
# create the smartcard insertion observer
self.cardtreecardobserver = self._CardObserver(self.cardtreectrl)
# register as a CardObserver; we will ge
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.cardtreecardobserver)
sizer.Add(
self.cardtreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
# create the reader tree
if appstyle & smartcard.wx.SimpleSCardApp.TR_READER:
self.readertreectrl = ReaderTreeCtrl(
self, clientpanel=clientpanel)
# create the reader insertion observer
self.readertreereaderobserver = self._ReaderObserver(
self.readertreectrl)
# register as a ReaderObserver; we will ge
# notified of added/removed readers
self.readermonitor = ReaderMonitor()
self.readermonitor.addObserver(self.readertreereaderobserver)
# create the smartcard insertion observer
self.readertreecardobserver = self._CardObserver(
self.readertreectrl)
# register as a CardObserver; we will get
# notified of added/removed cards
self.cardmonitor = CardMonitor()
self.cardmonitor.addObserver(self.readertreecardobserver)
sizer.Add(
self.readertreectrl, flag=wx.EXPAND | wx.ALL, proportion=1)
self.SetSizer(sizer)
self.SetAutoLayout(True)
def __init__(self, client):
# request any card type
#self.print_error("** client", client, " ** handler", client.handler)
self.client = client
self.parser = client.parser
self.cardtype = AnyCardType()
self.needs_2FA = None
try:
# request card insertion
self.cardrequest = CardRequest(timeout=10, cardType=self.cardtype)
self.cardservice = self.cardrequest.waitforcard()
# attach the console tracer
self.observer = LogCardConnectionObserver(
) #ConsoleCardConnectionObserver()
self.cardservice.connection.addObserver(self.observer)
# attach the card removal observer
self.cardmonitor = CardMonitor()
self.cardobserver = RemovalObserver(self)
self.cardmonitor.addObserver(self.cardobserver)
# connect to the card and perform a few transmits
self.cardservice.connection.connect()
# cache PIN
self.pin_nbr = None
self.pin = None
except CardRequestTimeoutException:
self.print_error('time-out: no card inserted during last 10s')
except Exception as exc:
self.print_error("Error during connection:", repr(exc),
traceback.format_exc())
def __init__(self, client):
# request any card type
self.client = client
self.parser = client.parser
self.cardtype = AnyCardType()
try:
# request card insertion
self.cardrequest = CardRequest(timeout=10, cardType=self.cardtype)
self.cardservice = self.cardrequest.waitforcard()
# attach the console tracer
self.observer = LogCardConnectionObserver(
) #ConsoleCardConnectionObserver()
self.cardservice.connection.addObserver(self.observer)
# attach the card removal observer
self.cardmonitor = CardMonitor()
self.cardobserver = RemovalObserver(self)
self.cardmonitor.addObserver(self.cardobserver)
# connect to the card and perform a few transmits
self.cardservice.connection.connect()
# cache PIN
self.pin_nbr = None
self.pin = None
except CardRequestTimeoutException:
_logger.exception('time-out: no card inserted during last 10s')
except Exception as exc:
_logger.exception("Error during connection: {str(exc)}")
def setStudentPresent(self):
self.start()
# Creation client com avec Serveur NFC
print('thread start')
client = Client(config.URI)
try:
lastID = ""
while self.run:
cardmonitor = CardMonitor()
cardobserver = ComUsb()
cardmonitor.addObserver(cardobserver)
time.sleep(1)
tmp = cardobserver.repUid
print(tmp)
if tmp != "" and tmp != lastID:
lastID = tmp
data = client.get('/1.0/user/byTag/' + tmp)
self.cours[self.idCour].setPresent(self.reseau,
data["login"],
"present")
self.gui.setStatus(data["login"], "present")
cardmonitor.deleteObserver(cardobserver)
except Exception as e:
print(str(e))
self.finished.emit()
def main():
try:
# initial screen
LOGGER_MAIN.info("System ready....")
global GPIO_CONTROL_MAIN
GPIO_CONTROL_MAIN = GPIOControl()
# card monitor
cardmonitor = CardMonitor()
cardobserver = BrizziCardObserver()
cardmonitor.addObserver(cardobserver)
# eternal loop
try:
while True:
time.sleep(1)
except Exception as err:
pass
# delete observer
cardmonitor.deleteObserver(cardobserver)
import sys
if 'win32' == sys.platform:
print('press Enter to continue')
sys.stdin.read(1)
except Exception as err:
pass
GPIO_CONTROL_MAIN.gpio_cleanup()
def __init__(self, args):
feedbackHandler.setup()
self.cardmonitor = CardMonitor()
self.cardobserver = cardWebconnector(args)
self.addCardObserver(self.cardobserver)
def __init__(self, card_list_env, auto_connect_env):
self.cardmonitor = CardMonitor()
self.card_list_env = card_list_env
self.auto_connect_env = auto_connect_env # TODO
# self.enable = True
# self.card_list = []
self.cardmonitor.addObserver(self)
def main():
global logger
global consumer
setup_logging()
logger = logging.getLogger(__name__)
logger.info(
"Insert MIFARE Desfire card to any reader to get its applications.")
available_reader = readers()
logger.info("Available readers: %s", available_reader)
if not available_reader:
sys.exit("No smartcard readers detected")
consumer = ConsumerThread()
consumer.start()
cardmonitor = CardMonitor()
cardobserver = MyObserver()
cardmonitor.addObserver(cardobserver)
try:
while True:
time.sleep(1)
finally:
consumer.alive = False
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(cardobserver)
def __init__(self):
self.card = None
self.card_value = None
self.card_type = None
cardmonitor = CardMonitor()
cardmonitor.addObserver(self)
def __init__(self, obs_impl=uid.ReadUidObserver):
# Declaration
self.__monitor = None
self.__observer = None
# Initialization
self.__monitor = CardMonitor()
self.__observer = obs_impl() # XXX: Extend to mutiple observer
def run():
cardmonitor = CardMonitor()
cardobserver = PhoneObserver()
cardmonitor.addObserver(cardobserver)
sleep(10)
cardmonitor.deleteObserver(cardobserver)
def main():
monitor = CardMonitor()
observer = TapObserver(handle_card)
monitor.addObserver(observer)
try:
while True:
time.sleep(5)
finally:
monitor.deleteObserver(observer)
def wait_for_device():
cardmonitor = CardMonitor()
cardobserver = PhoneObserver()
cardmonitor.addObserver(cardobserver)
print('Waiting for device...')
sleep(10)
cardmonitor.deleteObserver(cardobserver)
os._exit(1)
def __init__(self, callback):
threading.Thread.__init__(self)
#self._disable_buz()
self.cardmonitor = CardMonitor()
self.cardobserver = NfcReaderObserver(callback)
self.cardmonitor.addObserver(self.cardobserver)
self.run_event = threading.Event()
self.run_event.set()
def listen(self):
'''
The listen function is called during initialisation of the class & the
application. It initialises the process of starting to listen to card
taps on the reader.
'''
self.monitor = CardMonitor()
self.observer = Observer(self)
self.monitor.addObserver(self.observer)
def run(self):
logger.info("Iniciando monitor")
self.readermonitor = ReaderMonitor()
self.cardmonitor = CardMonitor()
self.cardobserver = DfvaCardObserver(eventmanager=self)
self.readerobserver = DFVAReaderObserver(eventmanager=self)
self.cardmonitor.addObserver(self.cardobserver)
self.readermonitor.addObserver(self.readerobserver)
self.run_mutex.lock()
self.run_mutex.lock()
def __init__(self, *args, **kwargs):
# base classes are old style classes so super() not allowed here
cmd.Cmd.__init__(self, *args, **kwargs)
self.reader = select_reader()
self.card = None
self.connection = None
self.sel_obj = ''
self.card_monitor = CardMonitor()
self.card_monitor.addObserver(self)
def cardMonitor(self, smart_card_insert_cb, smart_card_remove_cb):
self.smart_card_insert_cb = smart_card_insert_cb
self.smart_card_remove_cb = smart_card_remove_cb
if THAI_ID_CARD_DEBUG:
print("ThaiIDCard: Add SmartCard observer")
self.smart_card_monitor = CardMonitor()
self.smart_card_observer = SmartCardObserver(
card_insert_callback=self.smart_card_insert_cb,
card_remove_callback=self.smart_card_remove_cb)
self.smart_card_monitor.addObserver(self.smart_card_observer)
def main():
print('Insert or remove a smartcard in the system.')
print('')
cardmonitor = CardMonitor()
cardobserver = PrintObserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1)
cardmonitor.deleteObserver(cardobserver)
def main():
print("{} Starting NFC Monitor. Waiting for input.".format(now()))
lcd.lcd_display_string(line=1, string="Waiting to serve")
lcd.lcd_display_string(line=2, string=" (some coffee.) ")
init()
cardmonitor = CardMonitor()
cardobserver = DjangoInsertionObserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1)
def __init__(self, o2m=None):
print("NFCReader initializing...")
print("Insert or remove a smartcard in the system.")
print("")
self.log = logging.getLogger(__name__)
self.o2m = o2m
self.cardmonitor = CardMonitor()
self.cardobserver = PrintObserver()
self.cardmonitor.addObserver(self.cardobserver)
self.cardobserver.events.on_change += self.update_change
def poll():
"""poll for card
"""
cardmonitor = CardMonitor()
cardobserver = TapObserver()
cardmonitor.addObserver(cardobserver)
def delete():
print('Stopping')
cardmonitor.deleteObserver(cardobserver)
return delete
def __init__(self, ticket = None):
"Create and show main window."
self.main_window_xml = gtk.glade.XML(self.GLADE_FILE, "main")
self.main_window = self.main_window_xml.get_widget("main")
self.card_tabs = self.main_window_xml.get_widget("card_tabs")
while self.card_tabs.get_n_pages() > 0:
self.card_tabs.remove_page(0)
for t in self.CARD_TYPES:
a, b, l = gtk.Alignment(yscale=1,xscale=1,xalign=0.5,yalign=0.5), gtk.VBox(), gtk.Label(t[1])
a.add(b)
a.show()
b.show()
l.show()
self.card_tabs.append_page(a, tab_label=l)
self.ticket_button_group = gtk.RadioButton()
self.ticket_button_group._ticket = None
self.status_area = self.main_window_xml.get_widget("status_area")
self.known_readers = []
self.known_cards = {} # Note stupid: the keys to this dict are not objects from the known_readers list but rather reader name strings
self.connected_cards = {} # Again: the keys are not cards but repr(card)
self.tickets = {} # ditto
self.ticket_displayed = None # This is either None or a tuple (card object, ticket object)
self._update_status()
self.logbuf = FileLikeTextBuffer()
sys.stdout = self.logbuf.for_stream(sys.stdout)
sys.stderr = self.logbuf.for_stream(sys.stderr)
self.logview = self.main_window_xml.get_widget("logview")
self.logview.set_buffer(self.logbuf.buffer)
self.logbuf.add_view(self.logview)
signals = {
"on_exit_clicked": self.exit_clicked,
"on_main_delete_event": self.exit_clicked,
"on_main_destroy": gtk.main_quit,
}
self.main_window_xml.signal_autoconnect(signals)
self._clear_display()
self.rmon = ReaderMonitor()
self.cmon = CardMonitor()
self.rmon.addObserver(self)
self.cmon.addObserver(self)
def main():
# set event handlers
Event.on('insert', cardInsert)
Event.on('remove', cardRemove)
print('Scanning for cards')
cardmonitor = CardMonitor()
cardobserver = Observer()
cardmonitor.addObserver(cardobserver)
# remove the cardmonitor afterwards
# cardmonitor.deleteObserver(cardobserver)
while True:
continue
def daemon_body():
# The main loop
logging.info("INFO waiting for card... (hit CTRL+C to stop)")
try:
cardmonitor = CardMonitor()
cardobserver = printobserver()
cardmonitor.addObserver(cardobserver)
while True:
sleep(1000000) # sleep forever
except:
cardmonitor.deleteObserver(cardobserver)
def display_atr(self, reader="usb", verbose=False):
print_info("Scanning present readers...")
cardmonitor = CardMonitor()
selectobserver = ATRObserver(verbose)
cardmonitor.addObserver(selectobserver)
while True:
try:
sleep(0.1)
except KeyboardInterrupt:
print()
print_error("Module Interrupted")
cardmonitor.deleteObserver(selectobserver)
return True
def main():
if 'linux' in sys.platform and os.getegid() != 0:
sys.exit("You must to run this sctipt as root.")
available_reader = readers()
if not available_reader:
sys.exit("No card readers detected")
card_monitor = CardMonitor()
card_observer = KUSTDCardObserver()
card_monitor.addObserver(card_observer)
while True:
time.sleep(0.2)
def startLoop():
now = datetime.datetime.today()
directory = "%04u-%02u-%02u_%02uh%02um%02us" % \
(now.year, now.month, now.day, now.hour, now.minute, now.second)
os.makedirs(directory)
cardmonitor = CardMonitor()
cardobserver = observer(directory)
cardmonitor.addObserver(cardobserver)
while True:
try:
time.sleep(60)
except:
break
cardmonitor.deleteObserver(cardobserver)
def TapN():
print("Insert or remove a smartcard in the system.")
print("This program will exit in 10 seconds")
print("")
cardmonitor = CardMonitor()
cardobserver = PrintObserver()
cardmonitor.addObserver(cardobserver)
sleep(1)
# don't forget to remove observer, or the
# monitor will poll forever...
cardmonitor.deleteObserver(cardobserver)
import sys
if 'win32' == sys.platform:
print('press Enter to continue')
sys.stdin.read(1)
return cardobserver.Tap
def triggered_decorator(func):
# print("Starting observation of reader %s" % func.__defaults__[0])
class SimpleObserver(CardObserver):
reader = func.__defaults__[0]
def update(self, observable, actions):
added_cards, removed_cards = actions
# all readers involved in actions
action_readers = [c.reader for c in added_cards
] + [c.reader for c in removed_cards]
# if the one we observe is not the list, we return None
if not self.reader in action_readers:
return None
# card added
if len(added_cards):
for c in added_cards:
if c.reader == self.reader:
return func(action="inserted",
card=c,
reader=self.reader)
# card removed
if len(removed_cards):
for c in removed_cards:
if c.reader == self.reader:
return func(action="removed",
card=c,
reader=self.reader)
return None
# installing observer
cm = CardMonitor()
so = SimpleObserver()
cm.addObserver(so)
return so.update
