# Copyright 2009-2011 Klas Lindberg <klas.lindberg@gmail.com>

# This program is free software; you can redistribute it and/or modify it

# under the terms of the GNU General Public License version 3, as published

# by the Free Software Foundation.

import sys

import struct

import socket

import json

import math

from tactile import IR

class ID:

}

# there are Messages and Commands. Messages are inbound from the device and

# are used in communication between dwite and the conman. Commands are outbound

# to the hardware device.

# The parser produces Message instances while the Command base class has a

# virtual function serialize() that all subclasses must implement. The

# serialized representation shall be writable on the control connection's

# socket.

# to make things really funky, the SqueezeBox does not use network order to

# describe integers. It also uses different integer sizes to describe message

# and command lengths. On top of this, JSON messages must use a larger size

# field than SB messages to be useful. Joy...

#

# Device message: size field located [4:8], unsigned long, little endian.

# Device command: size field located [0:2], unsigned short, little endian.

# JSON message: exactly like device message.

class Message(object):

head = None # string

class Helo(Message):

self.mac_addr, self.uuid, self.language)

class Anic(Message):

return 'ANIC: -'

class Tactile(Message):

return 'IR R: %s %d' % (IR.codes_debug[-self.code], self.stress)

class Bye(Message):

return 'BYE : %d' % self.reason

class Stat(Message):

)

class Resp(Message):

return 'RESP: %s' % self.http_header

class Ureq(Message):

return 'UREQ: -'

class Dsco(Message):

return 'DSCO: %s' % message

### COMMANDS ###################################################################

class Command(object):

def serialize(self):

raise Exception, 'All Command subclasses must implement serialize()'

class Strm(Command):

return length + cmd + params

class StrmStart(Strm):

self.autostart = Strm.AUTOSTART_YES

class StrmStartMpeg(StrmStart):

StrmStart.__init__(self, ip, port, resource, seek, background)

class StrmStartFlac(StrmStart):

StrmStart.__init__(self, ip, port, resource, seek, background)

class StrmPause(Strm):

operation = Strm.OP_PAUSE

class StrmUnpause(Strm):

operation = Strm.OP_UNPAUSE

class StrmStop(Strm):

operation = Strm.OP_STOP

class StrmFlush(Strm):

operation = Strm.OP_FLUSH

class StrmStatus(Strm):

operation = Strm.OP_STATUS

class StrmSkip(Strm):

self.gain = (0, msecs) # there are many uses for this field..

class Grfe(Command):

return length + cmd + params

class Grfb(Command):

return length + cmd + params

class Aude(Command):

return length + cmd + params

class Audg(Command):

return length + cmd + params

class Updn(Command):

return length + cmd + params

class Visu(Command):

raise Exception, 'Visu must be subclassed'

class VisuNone(Visu):

return length + cmd + params

class VisuMeter(Visu):

return length + cmd + params

class VisuSpectrum(Visu):

return length + cmd + params

class Ping(Command):

return length + cmd + params

# JSON based messages. Note that there is no Command class for JSON messaging.

# all communication is done with a common tree of message classes.

class JsonMessage(Message):

self.wire.send(msg.serialize())

class JsonCall(JsonMessage):

return r

# this command is used by a content manager to hail a device manager. There

# is no reply message class.

class Hail(JsonCall):

JsonCall.__init__(self, guid, u'hail', params)

# used by device manager to ask content manager for a listing of the contents

# of some item by GUID. use JsonResult to reply.

class Ls(JsonCall):

JsonCall.__init__(self, guid, u'ls', params)

# used by content managers to send available search terms to the device

# manager. there is no reply message class.

class Terms(JsonCall):

JsonCall.__init__(self, guid, u'terms', { 'terms': terms })

class Play(JsonCall):

JsonCall.__init__(self, guid, u'play', params)

class Add(JsonCall):

JsonCall.__init__(self, guid, u'add', params)

class GetItem(JsonCall):

JsonCall.__init__(self, guid, u'get_item', { 'item': item })

class GetTerms(JsonCall):

def __init__(self, guid):

JsonCall.__init__(self, guid, u'get_terms', {})

class Search(JsonCall):

self.terms = terms

class JsonResult(JsonMessage):

return r

def parse_json(data):

return None

# only used to debug malformed messages

def parsable(data):

return True

def human_readable(data):

return buf

def first_unprintable(data):

return len(data)

def parse_header(head):

return (None, 0)

def parse_body(kind, size, body):

return None

def parse_helo_10(data, dlen):

return Helo(id, revision, mac_addr, 1234, 'EN')

def parse_helo_36(data, dlen):

return Helo(id, revision, mac_addr, uuid, language)

last_ir = None # tuple: (IR code, time stamp, stress)

def parse_ir(data, dlen):