iTunesIrcGateway (with TwitterIrcGateway)

itunes.py

# iTunesIrcGateway (with TwitterIrcGateway)
# -*- coding: utf-8 -*-

import clr
import re
import Misuzilla.Applications.TwitterIrcGateway
import Misuzilla.Applications.TwitterIrcGateway.AddIns.Console

from System import *
from System.Collections.Generic import *
from System.Diagnostics import Trace
from System.Runtime.InteropServices import Marshal
from Misuzilla.Applications.TwitterIrcGateway.AddIns import IConfiguration, ICustomConfiguration, ConfigurationPropertyInfo
from Misuzilla.Applications.TwitterIrcGateway.AddIns.Console import Context
from Misuzilla.Applications.TwitterIrcGateway.AddIns.DLRIntegration import DLRBasicConfiguration, DLRIntegrationAddIn, DLRContextHelper
from Misuzilla.Net.Irc import *

class iTunesConsole(object):
	def __init__(self, channel_name, session, server):
		self.channel_name = channel_name
		self.session = session
		self.server = server
	
	def setup(self):
		# Unload
		self.session.AddInManager.GetAddIn(DLRIntegrationAddIn).BeforeUnload += self.onBeforeUnload
		
		# Console
		self.console = Misuzilla.Applications.TwitterIrcGateway.AddIns.Console.Console()
		self.console.Attach(self.channel_name, self.server, self.session, DLRContextHelper.Wrap(CurrentSession, "iTunesContext", iTunesContext))

	def cleanup(self):
		# Console
		self.console.Detach()

	#region Events
	def onBeforeUnload(self, sender, args):
		self.cleanup()
	#endregion

class iTunesContext(Context):
	#region Context
	def Initialize(self):
		self.connect("iTunes.Application")
		self.itunes = self.com_object

	def GetCommands(self):
		d = Dictionary[String, String](Context.GetCommands(self))
		for m in [self.play, self.pause, self.next, self.prev, self.tracks, self.repeat, self.shuffle, self.check, self.uncheck, self.playlists, self.select]:
			d[m.__name__] = m.__doc__
		return d

	def OnUninitialize(self):
		self.disconnect()
	#endregion

	#region COM Connection
	def connect(self, progId):
		t = Type.GetTypeFromProgID(progId)
		self.com_object = Activator.CreateInstance(t)
		self.onCOMObjectConnected()

	def disconnect(self):
		self.onCOMObjectDisconnected()
		Marshal.FinalReleaseComObject(self.com_object)
		self.com_object = None
	#endregion

	#region COM Initialize
	def onCOMObjectConnected(self):
		self.com_object.OnCOMCallsEnabledEvent           += self.onCOMCallsEnabledEvent
		self.com_object.OnPlayerPlayingTrackChangedEvent += self.onPlayerPlayingTrackChangedEvent
		self.com_object.OnPlayerPlayEvent                += self.onPlayerPlayEvent
		self.com_object.OnPlayerStopEvent                += self.onPlayerStopEvent

	def onCOMObjectDisconnected(self):
		self.com_object.OnCOMCallsEnabledEvent           -= self.onCOMCallsEnabledEvent
		self.com_object.OnPlayerPlayingTrackChangedEvent -= self.onPlayerPlayingTrackChangedEvent
		self.com_object.OnPlayerPlayEvent                -= self.onPlayerPlayEvent
		self.com_object.OnPlayerStopEvent                -= self.onPlayerStopEvent
	#endregion

	#region Events
	def onCOMCallsEnabledEvent(self):
		pass

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

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

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

	#region Helper Methods
	def send_notice(self, message):
		self.Console.NotifyMessage(message)

	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)
	#endregion

	#region iTunes Control
	def repeat(self, opt = None):
		"""リピートの設定 (引数: [one|all|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 shuffle(self, opt = None):
		"""シャッフルの設定 (引数: [true|false])"""
		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 playlists(self, opt = None):
		"""プレイリスト一覧 (引数: [検索文字列])"""
		for i,playlist in enumerate(self.itunes.LibrarySource.Playlists):
			if (opt == None or opt == "") or (opt != None and (re.compile(opt).search(playlist.Name) != None)):
				self.send_notice(("%d: %s" % (i, playlist.Name)))

	def select(self, opt = None):
		"""プレイリストを選択して再生を開始  (引数: index)"""
		self.itunes.LibrarySource.Playlists[int(opt, 10) + 1].PlayFirstTrack()

	def tracks(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 check(self, args):
		"""チェックをつける (引数: index)"""
		self.toggleEnabled(True, args)
	def uncheck(self, args):
		"""チェックをはずす (引数: index)"""
		self.toggleEnabled(False, args)
	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)))

	def play(self, args):
		"""曲を再生します (引数: index)"""
		if args != "":
			self.itunes.CurrentPlaylist.Tracks.Item(int(args, 10) + 1).Play()
		else:
			self.itunes.Play()
	def next(self, args):
		"""次の曲へ"""
		self.itunes.NextTrack()
	def prev(self, args):
		"""前の曲へ"""
		self.itunes.PreviousTrack()
	def pause(self, args):
		"""一時停止"""
		self.itunes.Pause()
	#endregion

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