itunes.py

# -*- coding: utf-8 -*-

import clr
import re
import Misuzilla.Applications.TwitterIrcGateway
from System import *
from System.Diagnostics import Trace
from Misuzilla.Net.Irc import *
from System.Runtime.InteropServices import Marshal

class iTunesConsole(object):
	def __init__(self, channel_name, session, server):
		self.channel_name = channel_name
		self.session = session
		self.server = server

	#region Events

	def onCOMCallsEnabledEvent(self):
		pass

	def onPlayerPlayingTrackChangedEvent(self, track):
		Trace.WriteLine("iTunesConsole: onPlayerPlayingTrackChangedEvent: "+self.ToString())
		#self.send_notice(self.format(track))
		self.session.SendServer(TopicMessage(self.channel_name, self.format(self.itunes.CurrentTrack)))

	def onPlayerPlayEvent(self, track):
		Trace.WriteLine("iTunesConsole: onPlayerPlayEvent: "+self.ToString())
		#self.send_notice(self.format(track))
		self.session.SendServer(TopicMessage(self.channel_name, self.format(self.itunes.CurrentTrack)))

	def onPlayerStopEvent(self, track):
		Trace.WriteLine("iTunesConsole: onPlayerStopEvent: "+self.ToString())
		# 一時停止したときだけ送信する
		if self.itunes.PlayerState == 0:
			self.session.SendServer(TopicMessage(self.channel_name, self.format(self.itunes.CurrentTrack)))
			self.send_notice(self.format(track))

	def onBeforeUnload(self, sender, args):
		self.cleanup()

	def onPreMessageReceived(self, sender, eventargs):
		msg = eventargs.Message
		if (not isinstance(msg, (PrivMsgMessage, NoticeMessage)) or msg.Receiver != self.channel_name):
			return
		eventargs.Cancel = True
		self.process_line(msg.Content)

	#endregion
	
	def send_notice(self, message):
		notice_msg = NoticeMessage(self.channel_name, message)
		notice_msg.SenderNick = "iTunes"
		self.session.SendServer(notice_msg)

	def format(self, track):
		states = []
		if self.itunes.PlayerState == 0:
			states.append("[一時停止]")
		if track.Enabled:
			states.append("[x]")
		else:
			states.append("[ ]")
		if states:
			states.append("")
		
		return "%d: %s%s | %s | %s" % (track.Index-1, " ".join(states), track.Artist, track.Album, track.Name)
	
	# TODO: 後でいろいろ何とかする
	def process_line(self, content):
		content = content.lower()
		p = re.compile(r"^\s*([a-zA-Z]+)(?:\s+(.*$))?")
		m = p.match(content)
		if m:
			params = m.groups()
			if params[0] == "next":
				self.itunes.NextTrack()
			elif params[0] == "prev":
				self.itunes.PreviousTrack()
			elif params[0] == "pause":
				self.itunes.Pause()
			elif params[0] == "play":
				if m.groups()[1] != None:
					self.playByNumber(int(params[1], 10))
				else:
					self.itunes.Play()
			elif params[0] == "tracks":
				self.showPlaylistTracks(params[1])
			elif params[0] == "repeat":
				self.toggleRepeat(params[1])
			elif params[0] == "shuffle":
				self.toggleShuffle(params[1])
			elif params[0] == "check":
				self.toggleEnabled(True, params[1])
			elif params[0] == "uncheck":
				self.toggleEnabled(False, params[1])
			elif params[0] == "help":
				self.showHelp()
			else:
				self.send_notice("サポートされていないコマンドです。help コマンドで利用可能なコマンドの一覧を表示できます。")
	
	def showHelp(self):
		self.send_notice("play [index]: 再生")
		self.send_notice("pause: 一時停止")
		self.send_notice("next: 次の曲へ")
		self.send_notice("prev: 前の曲へ")
		self.send_notice("tracks: 現在のプレイリストの曲一覧")
		self.send_notice("repeat [one|all|none]: リピートの設定")
		self.send_notice("shuffle [true|false]: シャッフルの設定")
		self.send_notice("check index: チェックをつける")
		self.send_notice("uncheck index: チェックをはずす")

	#region iTunes Control
	def toggleRepeat(self, opt = None):
		if self.itunes.CanSetSongRepeat(self.itunes.CurrentPlaylist):
			if opt == None:
				self.itunes.CurrentPlaylist.SongRepeat = ((self.itunes.CurrentPlaylist.SongRepeat+1) % 3)
			else:
				opt = opt.Trim()
				if opt == "none":
					self.itunes.CurrentPlaylist.SongRepeat = 0
				elif opt == "one":
					self.itunes.CurrentPlaylist.SongRepeat = 1
				elif opt == "all":
					self.itunes.CurrentPlaylist.SongRepeat = 2

			if self.itunes.CurrentPlaylist.SongRepeat == 0:
				repeat_type = "リピートなし"
			elif self.itunes.CurrentPlaylist.SongRepeat == 1:
				repeat_type = "リピート(一曲)"
			elif self.itunes.CurrentPlaylist.SongRepeat == 2:
				repeat_type = "リピート(全曲)"

			self.send_notice(("リピートを %s に設定しました。" % repeat_type))
		else:
			self.send_notice("このプレイリストにリピートを設定することはできません")

	def toggleShuffle(self, opt = None):
		if self.itunes.CanSetSongRepeat(self.itunes.CurrentPlaylist):
			if opt == None:
				self.itunes.CurrentPlaylist.Shuffle = not self.itunes.CurrentPlaylist.Shuffle
			else:
				opt = opt.Trim()
				if opt == "true":
					self.itunes.CurrentPlaylist.Shuffle = True
				elif opt == "false":
					self.itunes.CurrentPlaylist.Shuffle = False
			self.send_notice(("シャッフルを %s に設定しました。" % ("有効" if self.itunes.CurrentPlaylist.Shuffle else "無効")))
		else:
			self.send_notice("このプレイリストにシャッフルを設定することはできません")

	def showPlaylistTracks(self, opt = None):
		self.send_notice("プレイリスト: %s" % (self.itunes.CurrentPlaylist.Name))
		start = end = None
		if opt:
			specs = opt.split('-', 1)
			if specs[1]:
				end = int(specs[1], 10)
			if specs[0]:
				start = int(specs[0], 10)
		for i, track in enumerate(self.itunes.CurrentPlaylist.Tracks):
			if start and i < start: continue
			if end is not None and i > end: break
			self.send_notice(self.format(track))

	def playByNumber(self, num):
		self.itunes.CurrentPlaylist.Tracks.Item(num + 1).Play()

	def toggleEnabled(self, mode, opts):
		for num in re.split(r'[, \t]', opts):
			num = int(num, 10)
			self.itunes.CurrentPlaylist.Tracks.Item(num + 1).Enabled = mode
			self.send_notice(self.format(self.itunes.CurrentPlaylist.Tracks.Item(num + 1)))

	#endregion
	
	def setup(self):
		self.session.PreMessageReceived += self.onPreMessageReceived
		
		# iTunes
		Trace.WriteLine("iTunesConsole: Setup")
		t = Type.GetTypeFromProgID("iTunes.Application")
		self.itunes = Activator.CreateInstance(t)
		self.itunes.OnCOMCallsEnabledEvent           += self.onCOMCallsEnabledEvent
		self.itunes.OnPlayerPlayingTrackChangedEvent += self.onPlayerPlayingTrackChangedEvent
		self.itunes.OnPlayerPlayEvent                += self.onPlayerPlayEvent
		self.itunes.OnPlayerStopEvent                += self.onPlayerStopEvent
		
		# Unload
		self.session.AddInManager.GetAddIn(Misuzilla.Applications.TwitterIrcGateway.AddIns.DLRIntegration.DLRIntegrationAddIn).BeforeUnload += self.onBeforeUnload

		# チャンネル
		if self.session.Groups.ContainsKey(self.channel_name):
			self.group = self.session.Groups[self.channel_name]
		else:
			self.group = Misuzilla.Applications.TwitterIrcGateway.Group(self.channel_name)
			self.session.Groups.Add(self.channel_name, self.group)
		
		self.group.IsSpecial = True
		self.group.IsJoined = True
		self.session.SendServer(JoinMessage(self.channel_name, ""))
		if self.itunes.CurrentTrack != None:
			self.session.SendServer(TopicMessage(self.channel_name, self.format(self.itunes.CurrentTrack)))
		Trace.WriteLine("iTunesConsole: Setup done")

	def cleanup(self):
		Trace.WriteLine("iTunesConsole: Cleanup")
		self.itunes.OnCOMCallsEnabledEvent           -= self.onCOMCallsEnabledEvent
		self.itunes.OnPlayerPlayingTrackChangedEvent -= self.onPlayerPlayingTrackChangedEvent
		self.itunes.OnPlayerPlayEvent                -= self.onPlayerPlayEvent
		
		Marshal.ReleaseComObject(self.itunes)
		self.itunes = None
		Trace.WriteLine("iTunesConsole: Cleanup done")

itunes_console = iTunesConsole("#iTunes", Session, Server)
itunes_console.setup()