def stream_server_start(self, *args, **kargs):
if self.is_streaming():
return
logging.info('StreamServer start: {}'.format(kargs))
self._stream_server = StreamServer(
kargs, lambda data: self.handler('server', data))
self._stream_server.start()
def __init__(self, target, adapter, size=None):
self.client = BluetoothAsyncSocket()
self.adapter = adapter
self.client.bind((self.adapter.bt_address, 0))
self.target = target
self.target_t = (target, 1)
self.size = size if size else 'QQVGA'
self.streamserver = StreamServer('0.0.0.0', CameraConnection.port)
self.streamserver.create_server_socket()
CameraConnection.port += 1
def run(self):
server.init_storage(path=args['--path'])
if args['--debug']:
# gevent's monkey patch messes pudb up
from streamserver import StreamServer
# keep it single threaded
args['--workers'] = 0
else:
from gevent.server import StreamServer
server.num_workers = int(args['--workers'])
server.run()
s = StreamServer(('0.0.0.0', int(args['--port'])), entry)
s.serve_forever()
def stream_server_start(self, *args, **kargs):
if self.is_streaming():
return
logging.info('StreamServer start: {}'.format(kargs))
self._stream_server = StreamServer(kargs, lambda data:
self.handler('server', data))
self._stream_server.start()
def __init__(self, target, adapter, size=None):
self.client = BluetoothAsyncSocket()
self.adapter = adapter
self.client.bind( (self.adapter.bt_address, 0) )
self.target = target
self.target_t = (target, 1)
self.size = size if size else 'QQVGA'
self.streamserver = StreamServer('0.0.0.0', CameraConnection.port)
self.streamserver.create_server_socket()
CameraConnection.port+=1
class Core(Thread):
def __init__(self, args, extra_args):
Thread.__init__(self)
self._args = args
self._extra_args = extra_args
self._threads = []
self._event_handler = CoreEventHandler()
if CrossPlatform.get().is_linux():
signal.signal(signal.SIGCHLD, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
def is_streaming(self):
if hasattr(self, '_stream_server') and self._stream_server is not None:
return True
return False
def stream_server_start(self, *args, **kargs):
if self.is_streaming():
return
logging.info('StreamServer start: {}'.format(kargs))
self._stream_server = StreamServer(kargs, lambda data:
self.handler('server', data))
self._stream_server.start()
def stream_server_stop(self):
if hasattr(self, '_stream_server') and self._stream_server is not None:
self._stream_server.stop()
self._stream_server = None
def playme(self, remote_ip, remote_port, service):
def myip(remote_ip):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((remote_ip, 0))
return s.getsockname()[0]
def xbmc():
stream_url = self._stream_server.url.format(ip=myip(remote_ip))
url = 'http://{}:{}/xbmcCmds/xbmcHttp?command=PlayFile({})'.format(
remote_ip, remote_port, stream_url)
req = urllib2.Request(url)
logging.info('url = {}'.format(url))
response = urllib2.urlopen(req, None, 5)
result = response.read()
logging.info('result: {}'.format(result))
def desktop_mirror():
stream_url = self._stream_server.url.format(ip=myip(remote_ip))
data_as_json = json.dumps({
'method': 'Player.Open',
'id': 1, 'jsonrpc': '2.0',
'params': {'item': {'file': stream_url}}}
)
url = 'http://{}:{}/jsonrpc'.format(remote_ip, remote_port)
logging.info('url = {}'.format(url))
logging.info(' json = {}'.format(data_as_json))
req = urllib2.Request(url, data_as_json,
{'Content-Type': 'application/json'})
response = urllib2.urlopen(req, None, 5)
result = response.read()
logging.info('result: {}'.format(result))
result = json.loads(result)
#switch back to json with pretty format
logging.debug(json.dumps(result, indent=4))
#logging.info('Got streaming url: {}'.
# format(self._stream_server.url))
#if service == '_desktop-mirror._tcp':
# desktop_mirror()
#else:
# xbmc()
desktop_mirror()
@property
def targets(self):
if not hasattr(self, '_avahi_browse'):
return dict()
return self._avahi_browse.targets
@property
def hosts(self):
if not hasattr(self, '_avahi_browse'):
return dict()
return self._avahi_browse.hosts
def run(self):
self._avahi_browse = AvahiService(lambda data:
self.handler('avahi', data))
self._stream_recever = StreamReceiver(lambda data:
self.handler('srx', data))
self._threads.append(self._avahi_browse)
self._threads.append(self._stream_recever)
for thread in self._threads:
thread.start()
for thread in self._threads:
thread.join()
def stop(self):
for thread in self._threads:
logging.debug('Stopping thread - {}'.format(thread.name))
thread.stop()
self.stream_server_stop()
def launch_selection_area_process(self):
SelectionArea(lambda data:
self.handler('selection', data)).start()
def register_listener(self, ui_window):
self._event_handler.register_listener(ui_window)
def on_event_relay(self, event_name, data):
self._event_handler.on_event_relay(event_name, data)
def on_event_stream_ready(self, event_name, data):
self._event_handler.on_event_stream_ready(event_name, data)
def handler(self, obj_id, data):
self._event_handler.handler(obj_id, data)
def signal_handler(self, signum, frame):
logging.info('signal: ' + str(signum))
if signal.SIGTERM == signum:
self.send_form_destroy()
try:
if CrossPlatform.get().is_linux():
if signal.SIGCHLD == signum:
os.waitpid(-1, os.WNOHANG)
except OSError:
pass
class CameraConnection():
port = 10000 # class variable
client = None # instance variables
target = None
adapter = None
state = None
index = 0
waiting_for_stop = False
server_socket = None
size = None
def __init__(self, target, adapter, size=None):
self.client = BluetoothAsyncSocket()
self.adapter = adapter
self.client.bind((self.adapter.bt_address, 0))
self.target = target
self.target_t = (target, 1)
self.size = size if size else 'QQVGA'
self.streamserver = StreamServer('0.0.0.0', CameraConnection.port)
self.streamserver.create_server_socket()
CameraConnection.port += 1
def connected(self):
logger.info("got connected")
self.state = FSM.WELCOME
self.client.setReadReady(self.data_available)
if len(self.client.read_buffer) > 0:
self.do_welcome()
def connection_failed(self, condition):
self.client.setCallback(None)
self.client.setErrCallback(None)
self.client.setReadReady(None)
self.adapter.disconnected(self.target)
def disconnect(self):
self.client.setCallback(None)
self.client.setErrCallback(None)
self.client.setReadReady(None)
self.adapter.disconnected(self.target)
self.client.close()
def connect(self):
self.state = FSM.CONNECTING
logger.info("connecting to %s from %s" %
(self.target_t, self.adapter.bt_address))
if self.adapter.manager.zm_backend:
self.pipe = '/tmp/camera_%s.pipe' % (self.target)
if not os.path.exists(self.pipe):
os.mkfifo(self.pipe)
return self.client.connect_ex(self.target_t, self.connected,
self.connection_failed)
def do_welcome(self):
if 'ACK0000' not in self.client.read_buffer:
return
logger.info("got welcome")
self.client.read_buffer = ""
self.state = FSM.SETUP
protocol.set_command_mode(self.client)
protocol.set_capture_mode(self.client, size=self.size)
self.state = FSM.IDLE
gobject.timeout_add(200, self.take_picture)
def take_picture(self):
logger.info("taking picture")
self.state = FSM.STREAM
protocol.send_command(self.client, "SET_PREVIEW_MODE")
#gobject.timeout_add(300,self.ask_size)
return False
def ask_size(self):
if self.state != FSM.ASK_SIZE:
return
logger.info("asking size")
self.state = FSM.GET_SIZE
protocol.send_command(self.client, 'GET_CAPTURE_SIZE')
def get_size(self):
if not CAPTURE_SIZE.match(self.client.read_buffer):
return
size = CAPTURE_SIZE.match(self.client.read_buffer).groupdict()['size']
self.size = size
logger.info("got size %s" % size)
self.state = FSM.STREAM
protocol.send_command(self.client, 'START_CAPTURE_SEND')
def extract_picture(self, start, end):
logger.info("got picture")
self.streamserver.send_to_all(self.client.read_buffer[start:end + 2],
mimetype='image/jpeg')
if self.adapter.manager.zm_backend:
logger.info("writing %i bytes" % (end - start))
asyncpipe.write(self.pipe, self.client.read_buffer[start:end + 2])
if self.adapter.manager.op_backend:
self.adapter.manager.tellListener(
signals.HANDLE_PICTURE,
dongle=self.adapter.bt_address,
target=self.target,
picture=self.client.read_buffer[start:end + 2])
self.index += 1
self.client.read_buffer = self.client.read_buffer[end + 2:]
def wait_for_prompt(self):
logger.info("wait for prompt")
if time.time() - self.last > 2:
logger.info("2 seconds without data, disconnect")
self.disconnect()
return False
return True
def do_stream(self):
start, end = protocol.find_jpeg(self.client.read_buffer)
if start > -1 and end > -1:
self.extract_picture(start, end)
if self.index == -100:
protocol.send_command(self.client, 'SET_COMMAND_MODE')
self.state = FSM.IDLE
self.last = time.time()
gobject.timeout_add(100, self.wait_for_prompt)
def data_available(self, amount):
if self.state == FSM.WELCOME:
self.do_welcome()
elif self.state == FSM.SETUP:
self.do_setup()
elif self.state == FSM.IDLE:
logger.info("ignoring I'm in idle")
self.last = time.time()
self.client.read_buffer = ""
elif self.state == FSM.ASK_SIZE:
self.ask_size()
elif self.state == FSM.GET_SIZE:
self.get_size()
elif self.state == FSM.STREAM:
self.do_stream()
else:
logger.debug("not valid state %s" % self.state)
elif data == 'onpause':
global lastStop
droid.log("GUI has gone onPause")
lastStop = time.time()
elif data == 'onresume':
global lastStop
lastStop = None
elif data.startswith('record_start'):
record_start(data.split('$')[1])
elif data == 'record_stop':
record_stop()
else:
droid.log("Not known event %s" % data)
server = StreamServer('', 10000, droid)
server.create_server_socket()
init = True
droid.toggleBluetoothState(True)
camera = Camera(droid, size="QQVGA", callback=callback, err_callback=error)
connect()
droid.startActivity('de.mjpegsample.MjpegSample')
while running:
server.wait_connection()
try:
if len(droid.bluetoothActiveConnections().result) > 0:
if droid.bluetoothReadReady():
elif data == "onpause":
global lastStop
droid.log("GUI has gone onPause")
lastStop = time.time()
elif data == "onresume":
global lastStop
lastStop = None
elif data.startswith("record_start"):
record_start(data.split("$")[1])
elif data == "record_stop":
record_stop()
else:
droid.log("Not known event %s" % data)
server = StreamServer("", 10000, droid)
server.create_server_socket()
init = True
droid.toggleBluetoothState(True)
camera = Camera(droid, size="QQVGA", callback=callback, err_callback=error)
connect()
droid.startActivity("de.mjpegsample.MjpegSample")
while running:
server.wait_connection()
try:
if len(droid.bluetoothActiveConnections().result) > 0:
if droid.bluetoothReadReady():
class CameraConnection():
port = 10000 # class variable
client = None # instance variables
target = None
adapter = None
state = None
index = 0
waiting_for_stop = False
server_socket = None
size = None
def __init__(self, target, adapter, size=None):
self.client = BluetoothAsyncSocket()
self.adapter = adapter
self.client.bind( (self.adapter.bt_address, 0) )
self.target = target
self.target_t = (target, 1)
self.size = size if size else 'QQVGA'
self.streamserver = StreamServer('0.0.0.0', CameraConnection.port)
self.streamserver.create_server_socket()
CameraConnection.port+=1
def connected(self):
logger.info("got connected")
self.state = FSM.WELCOME
self.client.setReadReady(self.data_available)
if len(self.client.read_buffer) > 0:
self.do_welcome()
def connection_failed(self, condition):
self.client.setCallback(None)
self.client.setErrCallback(None)
self.client.setReadReady(None)
self.adapter.disconnected(self.target)
def disconnect(self):
self.client.setCallback(None)
self.client.setErrCallback(None)
self.client.setReadReady(None)
self.adapter.disconnected(self.target)
self.client.close()
def connect(self):
self.state = FSM.CONNECTING
logger.info("connecting to %s from %s" % (self.target_t,
self.adapter.bt_address))
if self.adapter.manager.zm_backend:
self.pipe = '/tmp/camera_%s.pipe' % (self.target)
if not os.path.exists(self.pipe):
os.mkfifo(self.pipe)
return self.client.connect_ex(
self.target_t,
self.connected,
self.connection_failed)
def do_welcome(self):
if 'ACK0000' not in self.client.read_buffer:
return
logger.info("got welcome")
self.client.read_buffer = ""
self.state = FSM.SETUP
protocol.set_command_mode(self.client)
protocol.set_capture_mode(self.client, size=self.size)
self.state = FSM.IDLE
gobject.timeout_add(200,self.take_picture)
def take_picture(self):
logger.info("taking picture")
self.state = FSM.STREAM
protocol.send_command(self.client, "SET_PREVIEW_MODE")
#gobject.timeout_add(300,self.ask_size)
return False
def ask_size(self):
if self.state != FSM.ASK_SIZE:
return
logger.info("asking size")
self.state = FSM.GET_SIZE
protocol.send_command(self.client, 'GET_CAPTURE_SIZE')
def get_size(self):
if not CAPTURE_SIZE.match(self.client.read_buffer):
return
size = CAPTURE_SIZE.match(self.client.read_buffer).groupdict()['size']
self.size = size
logger.info("got size %s" % size)
self.state = FSM.STREAM
protocol.send_command(self.client, 'START_CAPTURE_SEND')
def extract_picture(self, start, end):
logger.info("got picture")
self.streamserver.send_to_all(
self.client.read_buffer[start:end+2],
mimetype='image/jpeg'
)
if self.adapter.manager.zm_backend:
logger.info("writing %i bytes" % (end-start))
asyncpipe.write(self.pipe, self.client.read_buffer[start:end+2])
if self.adapter.manager.op_backend:
self.adapter.manager.tellListener(
signals.HANDLE_PICTURE,
dongle = self.adapter.bt_address,
target = self.target,
picture = self.client.read_buffer[start:end+2]
)
self.index+=1
self.client.read_buffer = self.client.read_buffer[end+2:]
def wait_for_prompt(self):
logger.info("wait for prompt")
if time.time() - self.last > 2:
logger.info("2 seconds without data, disconnect")
self.disconnect()
return False
return True
def do_stream(self):
start, end = protocol.find_jpeg(self.client.read_buffer)
if start > -1 and end > -1:
self.extract_picture(start, end)
if self.index == -100:
protocol.send_command(self.client, 'SET_COMMAND_MODE')
self.state = FSM.IDLE
self.last = time.time()
gobject.timeout_add(100, self.wait_for_prompt)
def data_available(self, amount):
if self.state == FSM.WELCOME:
self.do_welcome()
elif self.state == FSM.SETUP:
self.do_setup()
elif self.state == FSM.IDLE:
logger.info("ignoring I'm in idle")
self.last = time.time()
self.client.read_buffer = ""
elif self.state == FSM.ASK_SIZE:
self.ask_size()
elif self.state == FSM.GET_SIZE:
self.get_size()
elif self.state == FSM.STREAM:
self.do_stream()
else:
logger.debug("not valid state %s" % self.state)
def get_iterators_for_model(model_type,
training_trace_set_paths,
validation_trace_set_paths,
conf,
batch_size=512,
hamming=False,
subtype='custom',
request_id=None):
# Stream samples from other machine?
if conf.online:
stream_server = StreamServer(conf)
batch_size = 32
else:
stream_server = None
batch_size = conf.batch_size
training_iterator = None
validation_iterator = None
if model_type == 'aicorrnet' or model_type == 'aiascad': # TODO unify with one iterator
training_iterator = AICorrSignalIterator(training_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server)
validation_iterator = AICorrSignalIterator(validation_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server)
elif model_type == 'aishacpu':
training_iterator = AISHACPUSignalIterator(training_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server,
hamming=hamming,
subtype=subtype)
validation_iterator = AISHACPUSignalIterator(
validation_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server,
hamming=hamming,
subtype=subtype)
elif model_type == 'aishacc':
training_iterator = AISHACPUSignalIterator(training_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server,
hamming=hamming,
subtype='custom')
validation_iterator = AISHACPUSignalIterator(
validation_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server,
hamming=hamming,
subtype='custom')
elif model_type == 'autoenc':
training_iterator = AutoEncoderSignalIterator(
training_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server)
validation_iterator = AutoEncoderSignalIterator(
validation_trace_set_paths,
conf,
batch_size=batch_size,
request_id=request_id,
stream_server=stream_server)
#elif model_type == 'aiascad': # TODO Remove me
# train_set, attack_set, metadata_set = load_ascad(join(conf.datasets_path, "ASCAD/ASCAD_data/ASCAD_databases/ASCAD.h5"), load_metadata=True)
# metadata_train, metadata_attack = metadata_set
# training_iterator = ASCADSignalIterator(train_set, meta=metadata_train)
# validation_iterator = ASCADSignalIterator(attack_set, meta=metadata_attack)
else:
logger.error("Unknown training procedure %s specified." % model_type)
exit(1)
return training_iterator, validation_iterator
import modelMangler as m
from model import *
from lxml import etree
TITLE = L('Spotify')
ICON = 'icon-default.png'
ART = "concert.jpeg"
ABOUT = "about1_1.png"
VERSION = "0.1.2"
data = DataService()
playback = PlaybackService()
playback.start()
streamserver = StreamServer(playback)
cache = dict()
####################################################################################################
def Start():
HTTP.CacheTime = None
ObjectContainer.art = R(ART)
Dict['LocalAddress']=Network.Address
Dict['PublicAddress']=Network.PublicAddress
Initialize()
Thread.Create(refreshLibraryIndex)
def Initialize():
Log.Debug("Initialize()")
# -*- coding: utf-8 -*-
# Copyright (C) 2008 Simon Pantzare
# See COPYING for details.
import cherrypy
from streamserver import StreamServer
import os.path
from code import interact
# Let us first set up the streaming server and add some media to it.
stream = StreamServer()
media = [("m1.mp3", "Sample_MP3_1"), ("m2.mp3", "Sample_MP3_2"),
("va1.mpg", "Sample_MPEG"),
("vidonly1.mpg", "Sample_MPEG_video_only_1"),
("vidonly2.mpg", "Sample_MPEG_video_only_2")]
for mp3 in range(0, 2):
stream.addMP3(*media[mp3])
stream.addMPEG(*media[2])
for mpg in range(3, len(media)):
stream.addMPEGVideo(*media[mpg])
# We could use a templating language but I think the extra dependencies is not
# worth it in this case.
html = """
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html lang="en">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>Streaming Server Demo</title>
<script src="http://prototypejs.org/assets/2008/1/25/prototype-1.6.0.2.js"
class Core(Thread):
def __init__(self, args, extra_args):
Thread.__init__(self)
self._args = args
self._extra_args = extra_args
self._threads = []
self._event_handler = CoreEventHandler()
if CrossPlatform.get().is_linux():
signal.signal(signal.SIGCHLD, self.signal_handler)
signal.signal(signal.SIGTERM, self.signal_handler)
def is_streaming(self):
if hasattr(self, '_stream_server') and self._stream_server is not None:
return True
return False
def stream_server_start(self, *args, **kargs):
if self.is_streaming():
return
logging.info('StreamServer start: {}'.format(kargs))
self._stream_server = StreamServer(
kargs, lambda data: self.handler('server', data))
self._stream_server.start()
def stream_server_stop(self):
if hasattr(self, '_stream_server') and self._stream_server is not None:
self._stream_server.stop()
self._stream_server = None
def playme(self, remote_ip, remote_port, service):
def myip(remote_ip):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect((remote_ip, 0))
return s.getsockname()[0]
def xbmc():
stream_url = self._stream_server.url.format(ip=myip(remote_ip))
url = 'http://{}:{}/xbmcCmds/xbmcHttp?command=PlayFile({})'.format(
remote_ip, remote_port, stream_url)
req = urllib2.Request(url)
logging.info('url = {}'.format(url))
response = urllib2.urlopen(req, None, 5)
result = response.read()
logging.info('result: {}'.format(result))
def desktop_mirror():
stream_url = self._stream_server.url.format(ip=myip(remote_ip))
data_as_json = json.dumps({
'method': 'Player.Open',
'id': 1,
'jsonrpc': '2.0',
'params': {
'item': {
'file': stream_url
}
}
})
url = 'http://{}:{}/jsonrpc'.format(remote_ip, remote_port)
logging.info('url = {}'.format(url))
logging.info(' json = {}'.format(data_as_json))
req = urllib2.Request(url, data_as_json,
{'Content-Type': 'application/json'})
response = urllib2.urlopen(req, None, 5)
result = response.read()
logging.info('result: {}'.format(result))
result = json.loads(result)
#switch back to json with pretty format
logging.debug(json.dumps(result, indent=4))
#logging.info('Got streaming url: {}'.
# format(self._stream_server.url))
#if service == '_desktop-mirror._tcp':
# desktop_mirror()
#else:
# xbmc()
desktop_mirror()
@property
def targets(self):
if not hasattr(self, '_avahi_browse'):
return dict()
return self._avahi_browse.targets
@property
def hosts(self):
if not hasattr(self, '_avahi_browse'):
return dict()
return self._avahi_browse.hosts
def run(self):
self._avahi_browse = AvahiService(
lambda data: self.handler('avahi', data))
self._stream_recever = StreamReceiver(
lambda data: self.handler('srx', data))
self._threads.append(self._avahi_browse)
self._threads.append(self._stream_recever)
for thread in self._threads:
thread.start()
for thread in self._threads:
thread.join()
def stop(self):
for thread in self._threads:
logging.debug('Stopping thread - {}'.format(thread.name))
thread.stop()
self.stream_server_stop()
def launch_selection_area_process(self):
SelectionArea(lambda data: self.handler('selection', data)).start()
def register_listener(self, ui_window):
self._event_handler.register_listener(ui_window)
def on_event_relay(self, event_name, data):
self._event_handler.on_event_relay(event_name, data)
def on_event_stream_ready(self, event_name, data):
self._event_handler.on_event_stream_ready(event_name, data)
def handler(self, obj_id, data):
self._event_handler.handler(obj_id, data)
def signal_handler(self, signum, frame):
logging.info('signal: ' + str(signum))
if signal.SIGTERM == signum:
self.send_form_destroy()
try:
if CrossPlatform.get().is_linux():
if signal.SIGCHLD == signum:
os.waitpid(-1, os.WNOHANG)
except OSError:
pass
# -*- coding: utf-8 -*-
# Copyright (C) 2008 Simon Pantzare
# See COPYING for details.
import cherrypy
from streamserver import StreamServer
import os.path
from code import interact
# Let us first set up the streaming server and add some media to it.
stream = StreamServer()
media = [("m1.mp3", "Sample_MP3_1"),
("m2.mp3", "Sample_MP3_2"),
("va1.mpg", "Sample_MPEG"),
("vidonly1.mpg", "Sample_MPEG_video_only_1"),
("vidonly2.mpg", "Sample_MPEG_video_only_2")]
for mp3 in range(0, 2):
stream.addMP3(*media[mp3])
stream.addMPEG(*media[2])
for mpg in range(3, len(media)):
stream.addMPEGVideo(*media[mpg])
# We could use a templating language but I think the extra dependencies is not
# worth it in this case.
html = """
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
"http://www.w3.org/TR/html4/strict.dtd">
<html lang="en">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>Streaming Server Demo</title>
