Example #1
0
	def getActiveDnsText(self):
		nameservers = list(self._service.nameservers())
		text = ""
		if nameservers:
			text = _("Active Nameservers:\n%s") %(", ".join(nameservers))
			Log.i(text)
		return text
Example #2
0
	def playService(self, ref, root=None):
		from Screens.InfoBar import InfoBar
		if root and InfoBar.instance:
			try:
				InfoBar.instance.servicelist.zap(ref, root)
				return
			except:
				try:
					from types import MethodType
					def zap(self, nref=None, root=None):
						self.revertMode=None
						ref = self.session.nav.getCurrentlyPlayingServiceReference()
						if not nref:
							nref = self.getCurrentSelection()
						if root:
							if not self.preEnterPath(root):
								self.clearPath()
								self.enterPath(eServiceReference(root))
						if ref is None or ref != nref:
							self.new_service_played = True
							self.session.nav.playService(nref)
							self.saveRoot()
							self.saveChannel(nref)
							config.servicelist.lastmode.save()
							self.addToHistory(nref)
					InfoBar.instance.servicelist.zap = MethodType(zap, InfoBar.instance.servicelist)
					InfoBar.instance.servicelist.zap(ref, root)
					return
				except:
					Log.w("Patch failed! Will fallback primitive zap")
					pass
		self.session.nav.playService(ref)
Example #3
0
	def _checkPackageRestore(self):
		from Plugins.SystemPlugins.SoftwareManager.SoftwareTools import iSoftwareTools
		bak = self._backupFile
		if not fileExists(bak):
			Log.i("Package backup does not exist... (%s)" %(bak,))
			return

		def doRestore(unused):
			available = []
			for p in iSoftwareTools.available_packetlist:
				available.append(p[0])

			with open(bak) as f:
				packagesAvailable = []
				packagesMissing = []
				for packagename in f:
					packagename = packagename.strip()
					if packagename in available:
						if not iSoftwareTools.installed_packetlist.has_key(packagename):
							packagesAvailable.append(packagename)
							Log.w("%s is NOT installed!" %packagename)
					else:
						packagesMissing.append(packagename)
				if packagesAvailable:
					self._session.open(PackageRestoreWizard, packagesAvailable, packagesMissing)
			self._moveBackupList()
		if iSoftwareTools.installed_packetlist and iSoftwareTools.available_packetlist:
			doRestore(None)
		else:
			def loadInstalled(unused):
				iSoftwareTools.startIpkgListInstalled(callback=doRestore)
			iSoftwareTools.startIpkgListAvailable(loadInstalled)
	def _onPixmapReady(self, picInfo=None):
		Log.d(picInfo)
		self._picInfo = picInfo
		self._nextPixmap = self._picload.getData()
		if self._immediateShow:
			self._immediateShow = False
			self._onTimeout()
Example #5
0
	def play(self):
		Log.i()
		self.setSeekState(self.SEEK_STATE_PLAY, onlyGUI=True)
		self.__delayed_close_timer.stop()
		self.setMetadata()
		if self.shown:
			self.checkSkipShowHideLock()
Example #6
0
def upnpMeta2DBMeta(meta):
	mapping = {
		Statics.META_ALBUM : eMediaDatabase.FIELD_ALBUM,
		#Statics.META_ALBUM_ART_URI : Statics.META_ALBUM_ART_URI, #TODO
		Statics.META_ARTIST : eMediaDatabase.FIELD_ARTIST,
		#Statics.META_BITRATE : Statics.META_BITRATE, #TODO
		Statics.META_DATE : eMediaDatabase.FIELD_DATE,
		Statics.META_DURATION : eMediaDatabase.FIELD_DURATION,
		Statics.META_GENRE : eMediaDatabase.FIELD_GENRE,
		#Statics.META_METATYPE : Statics.META_METATYPE, #TODO
		#Statics.META_RESOLUTION : Statics.META_RESOLUTION, #CONVERSION required!
		Statics.META_SIZE : eMediaDatabase.FIELD_SIZE,
		Statics.META_TITLE : eMediaDatabase.FIELD_TITLE,
		Statics.META_URI : eMediaDatabase.FIELD_FILE_URI,
	}
	meta_db = {}
	for key, value in meta.iteritems():
		if key == Statics.META_RESOLUTION:
			try:
				width, height = value.split("x")
				meta_db[eMediaDatabase.FIELD_WIDTH] = width
				meta_db[eMediaDatabase.FIELD_HEIGHT] = height
			except:
				Log.w("'%s' is no valid resolution!" %(value))
		else:
			newkey = mapping.get(key, None)
			if newkey:
				meta_db[newkey] = value
	return meta_db
Example #7
0
	def hide(self, screen):
		if screen == self._currentToast:
			self._onTimeout()
		elif screen in self._queue:
			self._queue.remove(screen)
		else:
			Log.w("Screen is not a toast or already about to be deleted %s" %(screen,))
	def __init__(self, *args, **kwargs):
		#we do have http basic auth, so whenever the user manages to load the page he is already authenticated
		self._authenticated = True
		self._failedAuthCount = 0
		self._sessionId = None
		self._requestID = 0
		Log.i("Protocol instance spawned!")
Example #9
0
	def _applyShare(self, data, callback):
		Log.i("activeMounts: %s" %(self._numActive,))
		if data['active']:
			mountpoint = AutoMount.MOUNT_BASE + data['sharename']
			if os_path.exists(mountpoint) is False:
				createDir(mountpoint)
			tmpsharedir = data['sharedir'].replace(" ", "\\ ").replace("$", "\\$")

			if data['mounttype'] == 'nfs':
				opts = self.sanitizeOptions(data['options'].split(','))
				remote = '%s:/%s' % (data['ip'], tmpsharedir)
				harddiskmanager.modifyFstabEntry(remote, mountpoint, mode="add_deactivated", extopts=opts, fstype="nfs")

			elif data['mounttype'] == 'cifs':
				opts = self.sanitizeOptions(data['options'].split(','), cifs=True)
				password = data['password']
				username = data['username'].replace(" ", "\\ ")
				if password:
					username = data['username'].replace(" ", "\\ ")
					opts.extend([
						'username=%s' % (data['username']),
						'password=%s' % (data['password']),
						])
				else:
					opts.extend(['guest'])
				opts.extend(['sec=ntlmv2'])
				remote = "//%s/%s" % (data['ip'], tmpsharedir)
				harddiskmanager.modifyFstabEntry(remote, mountpoint, mode="add_deactivated", extopts=opts, fstype="cifs")
		else:
			mountpoint = AutoMount.MOUNT_BASE + data['sharename']
			self.removeMount(mountpoint)
		if callback:
			callback(True)
Example #10
0
	def _parse(self, tree, types, defaults):
		def setFromTag(parent, key, data, bool=False):
			elements = parent.findall(key)
			if len(elements):
					val = elements[0].text
					if bool:
						val = val == "True"
					if val != None:
						data[key] = val

		keys = ['active', 'hdd_replacement', 'ip', 'sharedir', 'sharename', 'options', 'username', 'password']
		bool_keys = ['active', 'hdd_replacement']
		for i in range(0, len(types)):
			mounttype = types[i]
			for parent in tree.findall(mounttype):
				for mount in parent.findall("mount"):
					data = deepcopy(defaults[i])
					try:
						for key in keys:
							setFromTag(mount, key, data, key in bool_keys)
						Log.d("%s share %s" %(mounttype.upper(), data,))
						if data["active"]:
							self._numActive += 1
						#Workaround for nfs shares previously being saved without their leading /
						if mounttype == "nfs" and not data['sharedir'].startswith("/"):
							data['sharedir'] = "/%s" %(data['sharedir'],)
						self._mounts[data['sharename']] = data
					except Exception, e:
						Log.w("Error reading %s share: %s" %(mounttype.upper(), e))
Example #11
0
	def isAuthenticated(self, request):
		self._assignLocalNetworks(iNetworkInfo.getConfiguredInterfaces())
		if request.transport:
			host = IPNetwork(request.transport.getPeer().host)
			#If streamauth is disabled allow all acces from localhost
			if not config.plugins.Webinterface.streamauth.value:
				if self._isLocalHost(host.ip):
					Log.i("Streaming auth is disabled - Bypassing Authcheck because host '%s' is local!" %host)
					return True
			if not config.plugins.Webinterface.localauth.value:
				if self._isLocalClient(host.ip):
					Log.i("Local auth is disabled - Bypassing Authcheck because host '%s' is local!" %host)
					return True

		# get the Session from the Request
		http_session = request.getSession().sessionNamespaces

		# if the auth-information has not yet been stored to the http_session
		if not http_session.has_key('authenticated'):
			if request.getUser() and request.getPassword():
				http_session['authenticated'] = check_passwd(request.getUser(), request.getPassword())
			else:
				http_session['authenticated'] = False

		#if the auth-information already is in the http_session
		else:
			if http_session['authenticated'] is False:
				http_session['authenticated'] = check_passwd(request.getUser(), request.getPassword() )

		#return the current authentication status
		return http_session['authenticated']
Example #12
0
def readKeymap(filename):
	p = enigma.eActionMap.getInstance()
	assert p

	source = open(filename, 're')

	try:
		dom = xml.etree.cElementTree.parse(source)
	except:
		raise KeymapError("keymap %s not well-formed." % filename)

	keymap = dom.getroot()

	for cmap in keymap.findall("map"):
		context = cmap.attrib.get("context")
		assert context, "map must have context"

		advanced = None
		hasBle = False
		for device in cmap.findall("device"):
			devices = device.attrib.get("name")
			parseKeys(context, filename, p, devices, device)
			if devices.find("dreambox advanced remote control (native)") >= 0:
				advanced = device
			if devices.find("dreambox remote control (bluetooth le)") >= 0:
				hasBle = True
		if not hasBle and advanced:
			Log.w("BLE Keymap fallback to advanced remote  for context %s" %(context,))
			parseKeys(context, filename, p, "dreambox remote control (bluetooth le)", advanced)

		parseKeys(context, filename, p, "generic", cmap)
Example #13
0
	def addCurrentToPlaylist(self, play=False):
		Log.i("called")
		if self.canAddSelected():
			if self._list.canDescend():
				folder = self._list.getSelectedItem()
				if self.addFolderToPlaylist(folder):
					self.setStatus(self.getItemName(folder))
					return True
				else:
					self.setStatus(self.getItemName(folder), error=True)
			else:
				item, itemName, ref, extra = self.getSelectedItemData()
				if not item:
					self.setStatus(_("Nothing to add..."))
				else:
					if self._list.isValidType(item):
						if play:
							fnc = self.addAndPlay
						else:
							fnc = self.addToPlaylist
						if fnc(ref, extra):
							self.setStatus(itemName)
							return True
						else:
							self.setStatus(itemName, error=True)
					else:
						if self._type == MediaCore.TYPE_AUDIO:
							self.setStatus(_("Cannot add this file. It's not audio!"), error=True)
						if self._type == MediaCore.TYPE_VIDEO:
							self.setStatus(_("Cannot add this file. It's no video!"), error=True)
		return False
Example #14
0
	def _applyShare(self, data, callback):
		Log.d()
		if data['active']:
			mountpoint = AutoMount.MOUNT_BASE + data['sharename']
			Log.i("mountpoint: %s" %(mountpoint,))
			createDir(mountpoint)
			tmpsharedir = data['sharedir'].replace(" ", "\\040")

			if data['mounttype'] == 'nfs':
				opts = self.sanitizeOptions(data['options'].split(','))
				remote = '%s:%s' % (data['ip'], tmpsharedir)
				harddiskmanager.modifyFstabEntry(remote, mountpoint, mode="add_deactivated", extopts=opts, fstype="nfs")

			elif data['mounttype'] == 'cifs':
				opts = self.sanitizeOptions(data['options'].split(','), cifs=True)
				if data['password']:
					opts.extend([
						'username=%s' % (data['username']),
						'password=%s' % (data['password']),
						])
				else:
					opts.extend(['guest'])
				remote = "//%s/%s" % (data['ip'], tmpsharedir)
				harddiskmanager.modifyFstabEntry(remote, mountpoint, mode="add_deactivated", extopts=opts, fstype="cifs")
		else:
			mountpoint = AutoMount.MOUNT_BASE + data['sharename']
			self.removeMount(mountpoint)
		if callback:
			callback(True)
Example #15
0
	def _openGUI(self):
		if self.mimetype is None:
			self.mimetype = "video/mpeg"

		#picture are using the picviewer plugin
		if self.mimetype.startswith("image"):
			self.showPicture()
		else:#video or audio
			self._isPic = False
			if self._picView is not None:
				self._picView.close()

		#audio & video
		if not self._oldService:
			self._oldService = self.session.nav.getCurrentlyPlayingServiceReference()
		if self.mimetype.startswith('audio'):
			if self._audioGUI == None:
				Log.i("Starting AudioGUI")
				self._audioGUI = self.session.open(AudioGUI, self)
				self._audioGUI.onClose.append(self._reset)
				self._currentGui = self._audioGUI
			return self._audioGUI
		elif self.mimetype.startswith('video'):
		#if True:
			if self._videoGUI == None:
				Log.i("Starting VideoGUI")
				self._videoGUI = self.session.open(VideoGUI, self)
				self._videoGUI.onClose.append(self._reset)
				self._currentGui = self._videoGUI
			return self._videoGUI
	def go(self):
		item = self["list"].getCurrent()[0]
		if item is None or not isinstance(item, NetworkItem):
			return
		self.hostcache_file = "%s%s.cache" %(eEnv.resolve("${sysconfdir}/enigma2/"), item.name) #Path to cache directory
		if item.type == NetworkItem.TYPE_HOST: # host entry selected
			if item.host in self.expanded:
				self.expanded.remove(item.host)
				self.updateNetworkList()
				return
			else:
				if os_path.exists(self.hostcache_file):
					print '[Networkbrowser] Loading userinfo cache from ',self.hostcache_file
					try:
						self.hostdata = load_cache(self.hostcache_file)
						self.passwordQuestion(False)
						return
					except:
						Log.w("error loading host cache!")
			if "smb" in item.services:
				self.session.openWithCallback(self.passwordQuestion, MessageBox, text=_("Do you want to enter a username and password for this host?\n"), default=False )
			else:
				self.passwordQuestion(False)
		else:
			self.openMountEdit(item)
	def openMountEdit(self, item):
		if item and item.type != NetworkItem.TYPE_HOST:
			mounts = iAutoMount.getMounts()
			self.sharecache_file = None
			if item.type == NetworkItem.TYPE_NFS: # share entry selected
				data = iAutoMount.DEFAULT_OPTIONS_NFS
			if item.type == NetworkItem.TYPE_SMB: # share entry selected
				data = iAutoMount.DEFAULT_OPTIONS_CIFS
				self.sharecache_file = eEnv.resolve("${sysconfdir}/enigma2/") + item.name.strip() + '.cache' #Path to cache directory
				if os_path.exists(self.sharecache_file):
					print '[Networkbrowser] Loading userinfo from ',self.sharecache_file
					try:
						self.hostdata = load_cache(self.sharecache_file)
						data['username'] = self.hostdata['username']
						data['password'] = self.hostdata['password']
					except:
						pass
			data['active'] = True
			data['ip'] = item.host
			data['sharename'] = item.name
			data['sharedir'] = item.path
			for sharename, sharedata in mounts.items():
				if sharedata['ip'] == item.host and sharedata['sharedir'] == item.path:
					data = sharedata
					break
			Log.i(data)
			self.session.openWithCallback(self.MountEditClosed,AutoMountEdit, self.skin_path, data)
Example #18
0
	def addToPlaylist(self, ref, extra=None):
		if ref and ref.valid():
			self._player.addToPlaylist(ref, extra)
			return True
		else:
			Log.i("ERROR: No valid ref!")
			return False
Example #19
0
		def doStart(*args, **kwargs):
			if self._controlPoint:
				Log.w("already running!")
				return
			Log.i("starting now!")
			self._startPending = False
			self.coherence = Coherence({
				'logging': {
					'level' : 'warning', 
					'subsystem' : [
						{'name' : 'msearch', 'level' : 'warning'},
						{'name' : 'ssdp', 'level' : 'warning'}
					]}
				})
			self._controlPoint = ControlPoint(self.coherence, auto_client=['MediaServer','MediaRenderer'])
			self.coherence.ctrl = self._controlPoint
			self.__mediaServerClients = {}
			self.__mediaRendererClients = {}
			self.__mediaDevices = {}
			self.__devices = []
			self._controlPoint.connect(self._onMediaServerDetected, 'Coherence.UPnP.ControlPoint.MediaServer.detected')
			self._controlPoint.connect(self._onMediaServerRemoved, 'Coherence.UPnP.ControlPoint.MediaServer.removed')
			self._controlPoint.connect(self._onMediaRendererDetected, 'Coherence.UPnP.ControlPoint.MediaRenderer.detected')
			self._controlPoint.connect(self._onMediaRendererRemoved, 'Coherence.UPnP.ControlPoint.MediaRenderer.removed')
			self._controlPoint.connect(self._onMediaDeviceDectected, 'Coherence.UPnP.Device.detection_completed')
			self._controlPoint.connect(self._onMediaDeviceRemoved, 'Coherence.UPnP.RootDevice.removed')
			self.__deferredShutDown = None
			if self._session:
				self._callPlugins(reason=0)
Example #20
0
	def _onCredentialsPollBodyReady(self, body):
		if self._canceled:
			Log.d("Auth Request canceled")
			return
		result = json.loads(body)
		error = result.get("error", None)
		if error:
			if error == "authorization_pending":
				print "not ready, yet"
				reactor.callLater(self._user_code.interval, self._pollForResult)
			elif error == "slow_down":
				print "too fast, slowing down"
				self._device_code.interval = self._device_code.interval * 2
			elif error == "expired_token":
				self._onError(self.ERROR_CREDENTIALS_REQUEST_EXPIRED)
			else:
				print result
				self._onError(self.ERROR_CREDENTIALS_REQUEST_PARSE, error)
		elif "access_token" in result:
			access_token = result.get("access_token")
			refresh_token = result.get("refresh_token")
			token_expiry = str( int(time()) + int(result.get("expires_in")) )
			self._credentials = OAuth2Credentials(access_token, self.CLIENT_ID, self.CLIENT_SECRET, refresh_token, token_expiry, self.AUTH_REQUEST_URI, self.USER_AGENT)
			for fnc in self.onCredentialsReady:
				fnc(self._credentials)
		else:
			self._onError(self.ERROR_CREDENTIALS_REQUEST_PARSE, error)
Example #21
0
	def play(self, val, isUri):
		Log.w("%s %s" %(val, isUri))
		if not self.player:
			return
		if isUri:
			val = val.split("#")
			uri = val[0]
			if len(val) > 1:
				name = val[1]
			else:
				name = uri.split("/")[-1]
			if uri.startswith("file://") or uri.startswith("/"): #Local File
				if uri.lower().endswith(".ts"):
					serviceType = eServiceReference.idDVB
				elif uri.lower().endswith(".m2ts"):
					serviceType = eServiceReference.idM2TS
				else:
					serviceType = eServiceReference.idGST
				uri = uri.replace("file://", "")
				ref = eServiceReference(serviceType, 0, uri)
			else:
				ref = eServiceReference(eServiceReference.idURI, 0, uri)
				ref.setName(name)
		else:
			ref = eServiceReference(val)
		if not ref.valid():
			return False
		self.stop()
		self.player.playStream(ref);
		return True
	def do_auth(self, msg):
		msg = self.validate(msg, self.AUTH_MESSAGE_SCHEMA)
		if not msg:
			return
		id = msg['id']
		if 'session' in msg:
			session = msg['session']
			if self.server.checkSession(session):
				Log.w("session: %s" %(session))
				self._sessionId = session
				self.sendAuthOk()
				return
			else:
				self.sendAuthRequest()
				return
		token = msg['token']
		login = b64decode(token)
		user, password = login.split(":", 1)
		if check_passwd(user, password):
			self._authenticated = True
			self.sendAuthOk()
			return

		self._authenticated = False
		self._failedAuthCount += 1
		if self._failedAuthCount >= self.AUTH_FAIL_LIMIT:
			self._disconnect()
		result = {}
		self.sendError(id, 401, "Login failed! Wrong Credentials?")
		def resolve(self, service, uri):
			Log.i(uri)
			watch_url = None
			try:
				uri = uri.split("://")[1]
				uri = uri.split("/")
				if uri[0] == "live":
					watch_url = "https://youtube.com/user/%s/live" %(uri[1],)
				else:
					video_id = uri[0]
					watch_url = "https://youtube.com/watch?v=%s" % (video_id,)
			except:
				pass
			def onUrlReady(uri, format):
				Log.d("%s (%s)" %(uri, format))
				try:
					if not service.ptrValid():
						Log.w("Service became invalid!")
						return
					if uri:
						if VideoUrlRequest.isHls(format):
							service.setResolvedUri(uri, eServiceReference.idDVB)
						else:
							service.setResolvedUri(uri, eServiceReference.idGST)
					else:
						service.failedToResolveUri()
				except:
					service.failedToResolveUri()
			Log.i(watch_url)
			if watch_url:
				VideoUrlRequest(watch_url, [onUrlReady], async=True)
			else:
				service.failedToResolveUri()
			return True
	def sendJSON(self, msg):
		if not msg.has_key("id"):
			self._requestID += 1
			msg['id'] = self._requestID
		msg = json.dumps(msg).encode('utf8')
		Log.d("< %s" % (msg))
		self.sendMessage(msg)
	def onMessage(self, payload, isBinary):
		if isBinary:
			Log.w("Binary message received: {0} bytes".format(len(payload)))
		else:
			msg = json.loads(payload, 'utf8')
			Log.d("> %s" % (msg))
			self.onJSONMessage(msg)
Example #26
0
	def play(self, val, isUri):
		Log.w("%s %s" %(val, isUri))
		if isUri:
			val = val.split("#")
			uri = val[0]
			if len(val) > 1:
				name = val[1]
			else:
				name = uri.split("/")[-1]
			if uri.startswith("file://") or uri.startswith("/"): #Local File
				if uri.lower().endswith(".ts"):
					serviceType = eServiceReference.idDVB
				elif uri.lower().endswith(".m2ts"):
					serviceType = eServiceReference.idM2TS
				else:
					serviceType = eServiceReference.idGST
				uri = uri.replace("file://", "")
				ref = eServiceReference(serviceType, 0, uri)
			else:
				ref = eServiceReference(eServiceReference.idURI, 0, uri)
				ref.setName(name)
		else:
			ref = eServiceReference(val)
		if not ref.valid():
			return False
		if not self._player:
			self._player = self._session.openWithCallback(self._onPlayerClosed, MoviePlayer, ref)
		else:
			self._player.playService(ref)
		return True
Example #27
0
def addDefaultMenuItems():
	mediaCore.addToMainMenu((
		_("Music and Audiobooks"),
		AudioPlayer,
		{
			"key" : "music",
			"icon": getIcon("music"),
			"featuresPlaylist" : True
		}
	))
	mediaCore.addToMainMenu((
		_("Videos"),
		VideoPlayer,
		{
			"key" : "movies",
			"icon" : getIcon("movies"),
			"featuresPlaylist" : True
		}
	))
	try:
		from Plugins.Extensions.PicturePlayer.plugin import picshow
		mediaCore.addToMainMenu((
			_("Pictures"),
			picshow,
			{
				"key" : "pictures",
				"icon": getIcon("pictures"),
				"featuresPlaylist" : False
			}
		))
	except:
		Log.w("PicturePlayer is not available")
Example #28
0
	def reload(self):
		if not fileExists(self.CONFIG_FILE):
			return True
		try:
			with open(self.CONFIG_FILE) as f:
				self._config = {}
				for line in f:
					Log.i("parsing: %s" % (line,))
					if line.startswith("#"):
						Log.d("skipping comment")
						continue
					try:
						num, data = line.strip().split("=")
						pairs = data.split(",")
						tuner_data = {}
						for pair in pairs:
							key, value = pair.split(":")
							tuner_data[key] = value
						self._config[int(num)] = TunerEntry(tuner_data)
					except Exception as e:
						Log.w(e)
						continue
		except Exception as e:
			Log.w(e)
			return False
		Log.i(self._config)
		return True
Example #29
0
	def reload(self, force=True):
		self._isReloading = True
		if force:
			self._ipv4Changed = False
			self._ipv6Changed = False
		if not self._ipv6Changed:
			ip4 = self._service.ipv4()
			if not dict(ip4):
				ip6 = self._service.ipv4Config()
			self._config_ip4_method.value = ip4.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF)
			self._config_ip4_address.value = toIP4List( ip4.get("Address", "0.0.0.0") )
			self._config_ip4_mask.value = toIP4List( ip4.get(eNetworkService.KEY_NETMASK, "0.0.0.0") )
			self._config_ip4_gw.value = toIP4List( ip4.get(eNetworkService.KEY_GATEWAY, "0.0.0.0") )
		if not self._ipv6Changed:
			ip6 = self._service.ipv6()
			Log.i("%s / %s" %(dict(ip6), dict(self._service.ipv6Config())) )
			if not dict(ip6):
				ip6 = self._service.ipv6Config()
			self._config_ip6_method.value = ip6.get(eNetworkService.KEY_METHOD, eNetworkService.METHOD_OFF)
			self._config_ip6_address.value = ip6.get(eNetworkService.KEY_ADDRESS, "::")
			self._config_ip6_prefix_length.value = ord( ip6.get(eNetworkService.KEY_PREFIX_LENGTH, chr(1)) or chr(1) )
			self._config_ip6_gw.value = ip6.get(eNetworkService.KEY_GATEWAY, "::")
			self._config_ip6_privacy.value = ip6.get(eNetworkService.KEY_PRIVACY, eNetworkService.IPV6_PRIVACY_DISABLED)
		self._isReloading = False
		self._changed(None)
Example #30
0
	def _onUnboundRemoteKeyPressed(self, address, key):
		if key < 2 or key > 11 or key == self._lastUnboundKey:
			return
		self._lastUnboundKey = key
		Log.i("pressed %s on %s" %(key, address))

		# compare device addresses
		device = self._currentInputDevice
		if not device or (address != device.address()):
			self._setPendingPin("")
			Log.w("wrong address! %s" %(address))
			return

		pin = self._pins.get(address, None)
		if pin is None:
			self._setPendingPin("")
			return

		value = { 2 : 1, 3 : 2, 4 : 3, 5 : 4, 6 : 5, 7 : 6, 8 : 7, 9 : 8, 10 : 9, 11: 0 }.get(key, -1)
		pending = self._pendingPin.text.replace("-", "")

		if not pin.startswith(pending):
			self._setPendingPin(str(value))
		else:
			self._setPendingPin("%s%s" %(pending, value))
		if self._pendingPin.text == pin:
			self._pendingPin.text = _("PIN MATCH!")
			self._pins[device.address()] = self._genPin()
			self._connectDevice(device)
Example #31
0
	def _request(self):
		ie_key = "YoutubeLive" if "live" in self._baseurl.lower() else "Youtube"
		try:
			self._setupFormatMap()
			with YoutubeDL(self._params) as ytdl:
				result = ytdl.extract_info(self._baseurl, ie_key=ie_key, download=False, process=True)
				if self.KEY_ENTRIES in result: # Can be a playlist or a list of videos
					entry = result[self.KEY_ENTRIES][0] #TODO handle properly
				else:# Just a video
					entry = result
					fmt = entry.get(self.KEY_FORMAT_ID)
					url = ""
					suburi = ""
					for f in entry.get(self.KEY_REQUESTED_FORMATS, []):
						if not url and f.get(self.KEY_VCODEC, u"none") != u"none":
							url = str(f.get(self.KEY_URL, ""))
						elif not suburi and f.get(self.KEY_ACODEC, u"none") != u"none":
							suburi = str(f.get(self.KEY_URL, ""))
					if not url:
						url = str(entry.get(self.KEY_URL, ""))
					self._onResult(True, url, fmt, suburi)
		except Exception as e:
			Log.w(e)
			self._onResult(False, None, -1)
Example #32
0
 def startCmd(self, cmd, args=None):
     self.args = args
     if cmd == self.CMD_UPDATE:
         self.runCmd("update")
         self.update_done = True
     elif cmd == self.CMD_UPGRADE:
         append = ""
         if args["use_maintainer"]:
             append += " --force-maintainer"
         if args["test_only"]:
             append += " -test"
         self.runCmd("upgrade" + append)
     elif cmd == self.CMD_LIST:
         if args['installed_only']:
             self.runCmd("list-installed")
         else:
             self.runCmd("list")
     elif cmd == self.CMD_INSTALL:
         if args['package'].startswith('/'):
             self.preInstCmd = eConsoleAppContainer()
             self.preInstCmd_appClosed_conn = self.preInstCmd.appClosed.connect(
                 self.preInstCmdFinished)
             self.preInstCmd_dataAvail_conn = self.preInstCmd.dataAvail.connect(
                 self.cmdData)
             Log.i(
                 "A local package is to be installed: executing apt-get update before doing so"
             )
             self.preInstCmd.execute("apt-get update")
         else:
             self.runCmd("install " + args['package'])
     elif cmd == self.CMD_REMOVE:
         append = ""
         if args["autoremove"]:
             append = "--autoremove "
         self.runCmd("remove " + append + args['package'])
     self.setCurrentCommand(cmd)
Example #33
0
		def resolve(self, service, uri):
			Log.i(uri)
			uri = uri.replace('mp_euronews://','').lower().strip()
			if uri == 'en':
				uri = 'www'
			uri = "https://%s.euronews.com/api/watchlive.json" % uri
			def onUrlReady(uri):
				try:
					if not service.ptrValid():
						Log.w("Service became invalid!")
						return
					if uri:
						service.setResolvedUri(uri, eServiceReference.idGST)
					else:
						service.failedToResolveUri()
				except:
					service.failedToResolveUri()

			if uri:
				twAgentGetPage(uri).addCallback(self.parseLive, service)
			else:
				service.failedToResolveUri()

			return True
Example #34
0
		def resolve(self, service, uri):
			Log.i(uri)
			uri = uri.replace('mp_hlsproxy://','').replace('mp_hlsp://','')
			def onUrlReady(uri):
				try:
					if not service.ptrValid():
						Log.w("Service became invalid!")
						return
					if uri:
						self._bitrate = self._getBandwidth()
						path = config_mp.mediaportal.storagepath.value
						ip = "127.0.0.1" #".".join(str(x) for x in config_mp.mediaportal.hls_proxy_ip.value)
						import uuid
						uid = uuid.uuid1()
						uri = 'http://%s:%d/?url=%s&bitrate=%d&path=%s&uid=%s' % (ip, mp_globals.hls_proxy_port, uri, self._bitrate, path, uid)
						service.setResolvedUri(uri, eServiceReference.idGST)
					else:
						service.failedToResolveUri()
				except:
					service.failedToResolveUri()

			onUrlReady(uri)

			return True
Example #35
0
    def playService(self, ref, root=None):
        from Screens.InfoBar import InfoBar
        if root and InfoBar.instance:
            try:
                InfoBar.instance.servicelist.zap(ref, root)
                return
            except:
                try:
                    from types import MethodType

                    def zap(self, nref=None, root=None):
                        self.revertMode = None
                        ref = self.session.nav.getCurrentlyPlayingServiceReference(
                        )
                        if not nref:
                            nref = self.getCurrentSelection()
                        if root:
                            if not self.preEnterPath(root):
                                self.clearPath()
                                self.enterPath(eServiceReference(root))
                        if ref is None or ref != nref:
                            self.new_service_played = True
                            self.session.nav.playService(nref)
                            self.saveRoot()
                            self.saveChannel(nref)
                            config.servicelist.lastmode.save()
                            self.addToHistory(nref)

                    InfoBar.instance.servicelist.zap = MethodType(
                        zap, InfoBar.instance.servicelist)
                    InfoBar.instance.servicelist.zap(ref, root)
                    return
                except:
                    Log.w("Patch failed! Will fallback primitive zap")
                    pass
        self.session.nav.playService(ref)
    def _onData(self, data):
        Log.i(data)
        pre = _("Working...")
        isVerifying = False
        isFlashing = False

        if data.strip().startswith("flashing"):
            pre = _("Flashing firmware...")
            isFlashing = True
        elif data.strip().startswith("verifying"):
            pre = _("Verifying firmware...")
            isVerifying = True

        if self._isFrontProcessor:
            pre += _("\n\nDO NOT TURN OFF YOUR DREAMBOX!")
        if pre:
            if isFlashing or isVerifying:
                splitted = data.split(" ")
                address = splitted[3]
                if isFlashing:
                    self.blockFlashed += 1
                    text = _("%s\n\n%03d blocks written (%s)") % (
                        pre, self.blockFlashed, address)
                elif isVerifying:
                    self.blocksVerified += 1
                    text = _(
                        "%s\n\n%03d blocks written\n%03d blocks verified (%s)"
                    ) % (pre, self.blockFlashed, self.blocksVerified, address)
            else:
                text = "%s\n\n%s" % (pre, data)
        else:
            text = pre
        self["Text"].setText(text)
        self["text"].setText(text)
        if data.find("success:") >= 0:
            self._success = True
 def onUrlReady(uri):
     try:
         if not service.ptrValid():
             Log.w("Service became invalid!")
             return
         if uri:
             if ".m3u8" in uri:
                 if "hls_variant" in uri:
                     getPage(uri).addCallback(
                         self.parseData, service)
                 else:
                     uri = uri.replace('%252F', '%2F').replace(
                         '%253D', '%3D').replace('%252B',
                                                 '%2B').replace(
                                                     '%253B', '%3B')
                     service.setResolvedUri(uri,
                                            eServiceReference.idDVB)
             else:
                 service.setResolvedUri(uri,
                                        eServiceReference.idGST)
         else:
             service.failedToResolveUri()
     except:
         service.failedToResolveUri()
	def getNetworkIPs(self):
		Log.w()
		info = None
		sharelist = []
		if len(self._ip):
			strIP = "%s.0/24" %( ".".join(self._ip[0:3]) )
			info = [x for x in netscan.netInfo(strIP) if x[2] != '.'.join(self._ip)]
			Log.i(info)
		else:
			Log.w("IP FAULTY! %s" %self._ip)
		reactor.callFromThread(self._onNetworkIPsReady, info)
Example #39
0
 def _getTunerCount(self, ip, type):
     if not ip in self._check_count_lut:
         Log.w("ip not in lut!")
         return 0
     host_entry = self._check_count_lut[ip]
     if not type in host_entry:
         Log.w("type not in lut!")
         return 0
     count = host_entry[type]
     Log.w(count)
     return count
Example #40
0
 def _reloadFromDiskCache(self):
     f = resolveFilename(SCOPE_CONFIG,
                         "%s/%s" % (self.CACHE_DIR_NAME, "genres"))
     if fileExists(f):
         Log.w("Reloading services from disk cache")
         data = None
         with open(f) as fdesc:
             data = json.load(fdesc)
             for key, data in data.iteritems():
                 genre = StalkerGenre(data)
                 self._genres[key] = genre
                 self._allServices.update(genre.services)
                 Log.i("Loaded genre %s from cache!" % (genre, ))
         self._isFinishedLoadingGenres = True
         self._isFinishedLoadingChannels = True
         Log.w("Loaded %s services from cache!" %
               (len(self._allServices, )))
     else:
         Log.w("No Cache available!")
Example #41
0
 def _mainMenuItemSanityCheck(self, item):
     #check if the given item is a list like this: ( "Menu Text", ScreenSubclass, { "key" : "menukey", "iconpath" : "blabla", featuresPlaylist: True/False } )
     if len(item) < 3:
         Log.i("item doesn't have enough entries")
         return False
     if not issubclass(item[1], Screen):
         Log.i("item[1] is not a Screen")
         return False
     if not isinstance(item[2], dict):
         Log.i("item[2] is NOT a dict")
         return False
     return True
Example #42
0
 def writeToDatabase(self, imageResultDict):
     '''
     information write to database
     :param infoDict:
     :return:
     '''
     if imageResultDict is None:
         logger.error("imageResultDict is None")
         return None
     try:
         result = self._database.queryIsExist("image", {"md5": imageResultDict["md5"]})
         progressBar = self.computeProgressBar(self.completed, self.totalDownload)
         if not result:
             logger.info("Image completed: {progressBar: <10}".format(progressBar=progressBar) + \
                         "Title:{title}".format(title=imageResultDict['title']),
                         level="ALL")
             self._database.insert("image", imageResultDict)
     except BaseException:
         logger.error(traceback.format_exc())
         logger.error("An error occurred in the function ---> wirteToDataBase")
         return None
    def getNetworkIPs(self, host):
        Log.i("Detecting availablility of NFS or SMB services on host %s" %
              host)
        item = None
        services = []

        if self._probeTcpPort(host, 445) or self._probeTcpPort(host, 139):
            Log.i("Found SMB server on %s" % host)
            services.append("smb")

        if rpcinfo.progping('udp', host, 'nfs') or rpcinfo.progping(
                'tcp', host, 'nfs'):
            Log.i("Found NFS server on %s" % host)
            services.append("nfs")

        if services:
            hostname = self._lookupHostname(host)
            item = NetworkItemHost(hostname, host, services)

        Log.i(item)
        reactor.callFromThread(self._onNetworkIPsReady, item)
Example #44
0
 def _onSharesApplied(self):
     Log.d()
     for sharename, data in self._mounts.items():
         mountpoint = AutoMount.MOUNT_BASE + sharename
         Log.d("mountpoint: %s" % (mountpoint, ))
         if os_path.exists(mountpoint):
             if os_path.ismount(mountpoint):
                 Log.d("'%s' is mounted" % (mountpoint, ))
                 data['isMounted'] = True
                 desc = data['sharename']
                 if data['hdd_replacement']:  #hdd replacement hack
                     self._linkAsHdd(mountpoint)
                 harddiskmanager.addMountedPartition(mountpoint, desc)
             else:
                 Log.d("'%s' is NOT mounted" % (mountpoint, ))
                 sharename = self._mounts.get(data['sharename'], None)
                 if sharename:
                     data['isMounted'] = False
                 if os_path.exists(mountpoint):
                     if not os_path.ismount(mountpoint):
                         removeDir(mountpoint)
                         harddiskmanager.removeMountedPartition(mountpoint)
Example #45
0
 def bodyCB(body):
     if isinstance(body, Failure):
         if isinstance(body.value, PartialDownloadError):
             body = body.value.response
         else:
             Log.w(body)
             callback(None)
             return
     try:
         result = json.loads(unicode(body))
         Log.d(result)
         callback(result)
     except Exception as e:
         Log.w(body)
         callback(None)
Example #46
0
	def getDetailsByRef(self, ref):
		path = ref.getPath()
		#if we get only a reference or an entry with "extra data" but no file id yet we ask the database to enrich the data
		if path.startswith("/"):
			Log.i("Asking database for details!")
			db = eMediaDatabase.getInstance()
			res = db.getFileByPath(path)
			if res and res.data() and not res.error() :
				return dict(res.data()[0])
			else:
				Log.i("ERROR: %s :: %s" %(res.errorDatabaseText(), res.errorDriverText()))
		else:
			Log.i("%s is not an absolute local path, skip querying the database" % path)

		return None
Example #47
0
	def save(self):
		if self._ipv4Changed:
			Log.i("IPv4 Changed, saving!")
			if self._config_ip4_method.value == eNetworkService.METHOD_MANUAL:
				ip4_config = {
						eNetworkService.KEY_METHOD : self._config_ip4_method.value,
						eNetworkService.KEY_ADDRESS : toIP4String(self._config_ip4_address),
						eNetworkService.KEY_NETMASK : toIP4String(self._config_ip4_mask),
						eNetworkService.KEY_GATEWAY : toIP4String(self._config_ip4_gw),
					}
			else:
				ip4_config = { eNetworkService.KEY_METHOD : self._config_ip4_method.value }
			Log.i(ip4_config)
			self._service.setIpv4Config(ip4_config)

		if self._ipv6Changed:
			Log.i("IPv6 Changed, saving!")
			if self._config_ip6_method.value == eNetworkService.METHOD_MANUAL:
				ip6_config = {
						eNetworkService.KEY_METHOD : self._config_ip6_method.value,
						eNetworkService.KEY_ADDRESS : self._config_ip6_address.value,
						eNetworkService.KEY_PREFIX_LENGTH : self._config_ip6_prefix_length.value,
						eNetworkService.KEY_GATEWAY : self._config_ip6_gw.value,
						eNetworkService.KEY_PRIVACY : self._config_ip6_privacy.value,
					}
			else:
				val = self._config_ip6_method.value #avoid config element overhead here
				#one can not configure 6to4, it will automatically be applied by connman if applicable -> change it to auto
				if val == eNetworkService.METHOD_6TO4:
					val = eNetworkService.METHOD_AUTO

				ip6_config = { eNetworkService.KEY_METHOD : val }
				if val != eNetworkService.METHOD_OFF:
					ip6_config[eNetworkService.KEY_PRIVACY] = self._config_ip6_privacy.value
			Log.i(ip6_config)
			self._service.setIpv6Config(ip6_config)
Example #48
0
	def get(id=-1, name=None, type=MediaCore.TYPE_AUDIO, create=False):
		# If we'er called with only the name given we'll try to get the id.
		# If we cannot find a matching playlist, we return None
		db = eMediaDatabase.getInstance()
		if id < 0:
			res = db.getPlaylistByName(name, type)
		else:
			res = db.getPlaylist(id)
		if res.error() or not res.data(): #Playlist unkown (not yet saved/created!)
			Log.w("%s / %s" %(res.errorDatabaseText(), res.errorDriverText()))
			if create:
				Log.i("creating new playlist")
				return DatabasePlaylist.create(name, type)
			else:
				Log.w("Unkown Playlist for id=%s, name=%s and type=%s" %(id, name, type))
				return None

		data = res.data()[0]
		id = int(data[eMediaDatabase.FIELD_ID])
		name = data[eMediaDatabase.FIELD_NAME]
		Log.i("Playlist %s found. Id is %s" %(name, id))
		playlist = DatabasePlaylist(id, name=name, type=type)
		playlist.reload()
		return playlist
Example #49
0
	def onCheckDevices(self, allDevices = False):
		for d in self._devices.values():
			if not allDevices:
				if not d.logicalAddress in (eCec.ADDR_AUDIO_SYSTEM, eCec.ADDR_TV):
					return
			commands = []
			if allDevices and d.physicalAddress == (0xff,0xff):
				Log.i("requesting physical address of %s" %(d.logicalAddress,))
				commands.append(eCec.MSG_GIVE_PHYS_ADDR)
			if d.vendor == eCec.VENDOR_UNKNOWN:
				Log.i("requesting vendor of %s" %(d.logicalAddress))
				commands.append(eCec.MSG_GIVE_DEVICE_VENDOR_ID)
			if allDevices and not d.name:
				Log.i("requesting name of %s" %(d.logicalAddress,))
				commands.append(eCec.MSG_GIVE_OSD_NAME)
			commands.append(eCec.MSG_GIVE_DEVICE_POWER_STATUS)
			[self.send(d.logicalAddress, cmd) for cmd in commands]
Example #50
0
	def _onPictureReady(self, nothing):
		Log.i("file=%s" %self._imageFile)
		try:
			from PictureGUI import PictureGUI
			path = "%s/" %( "/".join( self._imageFile.split("/")[0:-1] ) )
			name = self._imageFile.split("/")[-1]
			filelist = [((self._imageFile, False), None)]

			Log.i("path=%s, name=%s, filelist=%s" %(path, name, filelist))
			if self._picView is None:
				self._picView = self.session.open(PictureGUI, filelist, 0, path)
				self._currentGui = self._picView
			else:
				self._picView.setFileList(filelist, 0, path)
			self._picView.onClose.append(self._reset)
		except Exception as e:
			Log.w(e)
			msgbox = self.session.open(MessageBox, _("Showing a picture from '%s' failed!") %self.uri, type=MessageBox.TYPE_ERROR, timeout=20)
			msgbox.setTitle( _("UPnP/DLNA - Failed to show picture") )
Example #51
0
 def _applyUriParameters(self, params):
     ref = str(params.get(self.URI_PARAM_REF, [""])[0])
     ref = eServiceReference(ref)
     if ref.valid():
         Log.i("setting encoder service to %s" % ref.toString())
         self.setEncoderService(ref)
     vb = params.get(self.URI_PARAM_VIDEO_BITRATE, [-1])[0]
     if vb > 0:
         try:
             Log.i("setting video bitrate to %s" % vb)
             self.videoBitrate = int(vb)
         except:
             pass
     ab = params.get(self.URI_PARAM_AUDIO_BITRATE, [-1])[0]
     if ab > 0:
         try:
             Log.i("setting audio bitrate to %s" % ab)
             self.audioBitrate = int(ab)
         except:
             pass
Example #52
0
 def _onMediaDeviceDectected(self, device):
     if device.udn in self.__mediaDevices:
         return
     self.__mediaDevices[device.udn] = device
     device_type = device.get_friendly_device_type()
     if device_type == self.DEVICE_TYPE_SATIP_SERVER:
         Log.i("New SAT>IP Server found: %s (%s - %s)" %
               (device.get_friendly_name(),
                device.get_friendly_device_type(), device.get_satipcap()))
         for fnc in self.onSatIpServerDetected:
             fnc(device)
     elif device_type == self.DEVICE_TYPE_DREAMBOX:
         Log.i(
             "New Dreambox found: %s (%s - %s)" %
             (device.get_friendly_name(), device.get_friendly_device_type(),
              device.get_presentation_url()))
         for fnc in self.onDreamboxDetected:
             fnc(device)
     else:
         Log.i("New Device found: %s (%s)" %
               (device.get_friendly_name(),
                device.get_friendly_device_type()))
Example #53
0
 def checkUpgrade(self):
     if config.misc.firstrun.value:
         return
     requiresSetup = False
     if config.timezone.version.value == 0:
         try:
             currentZone = self.getCurrentTimezone()
             Log.w(currentZone)
             if currentZone.endswith('Istanbul'):
                 Log.w(
                     "Current timezone is Europe/Istanbul. User needs to verify!"
                 )
                 requiresSetup = True
         except:
             pass
         config.timezone.version.value = 1
     if config.timezone.version.value == 1:
         requiresSetup = True
         config.timezone.version.value = 2
     if requiresSetup:
         Log.w("Upgraded to new timezone handling - Require setup!")
         Notifications.AddNotification(Setup, "timezone")
     config.timezone.version.save()
Example #54
0
 def _startEncoderService(self, service):
     if not self.isAnyEnabled() \
      or int(config.streamserver.source.value) != self.INPUT_MODE_BACKGROUND \
      or self.sourceState <= eStreamServer.SOURCE_STATE_READY:
         self.stopEncoderService()
         Log.i(
             "Streamserver disabled, not in TV Service mode or no client connected, will not allocate service (%s, %s, %s, %s, %s)"
             % (config.streamserver.rtsp.enabled.value,
                config.streamserver.hls.enabled.value,
                config.streamserver.mediator.enabled.value,
                config.streamserver.source.value,
                self._streamServer.sourceState()))
         return self.ENCODER_SERVICE_INVALID_MODE
     ref = self._getRef(service)
     if ref:
         cur_ref = self._encoderService
         cur_ref = cur_ref and cur_ref.info()
         cur_ref = cur_ref and cur_ref.getInfoString(
             iServiceInformation.sServiceref)
         if cur_ref == ref.toString():
             Log.i(
                 "ignore request to play already running background streaming service (%s)"
                 % cur_ref)
             return self.ENCODER_SERVICE_ALREADY_ACTIVE
         else:
             self.stopEncoderService()
             self._encoderService = eServiceCenter.getInstance().play(ref)
             if self._encoderService and not self._encoderService.setTarget(
                     self.ENCODER_TARGET):
                 Log.i("Starting encoder service [%s]!" %
                       (service.toCompareString()))
                 self._encoderService.start()
                 return self.ENCODER_SERVICE_SET
             else:
                 return self.ENCODER_SERVICE_INSUFFICIENT_RESOURCES
     return self.ENCODER_SERVICE_INVALID
Example #55
0
	def _onReady(self, logicalAddress, physicalAddress, force=False):
		oldPhysical = self._physicalAddress
		self._logicalAddress = logicalAddress
		self._physicalAddress = tuple(physicalAddress)

		if self._activeSource == oldPhysical and self.isReady():
			self.handleActiveSource(physicalAddress)

		Log.i("Physical address: %s # Logical address: %s" %(self.physicalToString(self._physicalAddress), self._logicalAddress))
		if not self.getDevice(eCec.ADDR_TV):
			self.givePhysicalAddress(eCec.ADDR_TV)

		if self.isReady():
			if oldPhysical != self._physicalAddress or force:
				self.reportPhysicalAddress()
				self.givePhysicalAddress(eCec.ADDR_AUDIO_SYSTEM)
				self.giveSystemAudioModeStatus()
			if isPendingOrVisibleNotificationID("Standby"):
				Log.i("Standby pending. Doing nothing")
				return
			if Standby.inStandby == None:
				self.powerOn()
			else:
				Log.i("Standby, not waking up.")
Example #56
0
    def reload(self):
        self._list = []
        db = eMediaDatabase.getInstance()
        res = None
        if self._id < 0:  #no @staticmethod get() used, probably....
            self._valid = False
            self.listChanged()
            Log.w("A Playlist with the name/id %s/%s does not exist!" %
                  (self._name, self._id))
            return

        res = db.getPlaylistItemsById(self._id)
        if res and not res.error():
            for data in res.data():
                data = dict(data)
                file_uri = data.get(eMediaDatabase.FIELD_FILE_URI, None)
                if not file_uri:
                    Log.w("Playlist entry invalid, %s" % data)
                    continue
                if file_uri.endswith('.ts'):
                    ref = eServiceReference(eServiceReference.idDVB, 0,
                                            file_uri)
                elif file_uri.endswith('.m2ts'):
                    ref = eServiceReference(eServiceReference.idM2TS, 0,
                                            file_uri)
                else:
                    ref = eServiceReference(eServiceReference.idGST, 0,
                                            file_uri)
                self.add(ref, data, True)
            self._valid = True
        else:
            Log.i("Error loading playlist %s:%s\n%s\n%s" %
                  (self._id, self._name, res.errorDatabaseText(),
                   res.errorDriverText()))
            self._valid = False
        self.listChanged()
Example #57
0
	def log(self, data):
		Log.w("# %s" % (data,))
Example #58
0
 def stopEncoderService(self):
     if self._encoderService:
         Log.i("Stopping encoder service (%s)" %
               (self._currentService.toCompareString()))
         self._encoderService.stop()
     self._encoderService = None
Example #59
0
 def _onDBusError(self, error):
     Log.w("DBUS ERROR! %s" % (error, ))
     Notifications.AddPopup("%s" % (error, ),
                            MessageBox.TYPE_ERROR,
                            -1,
                            domain=NOTIFICATION_DOMAIN_STREAMSERVER)
Example #60
0
 def _onUriParametersChanged(self, parameters):
     Log.i("%s" % (parameters))
     params = parse_qs(parameters)
     self._applyUriParameters(params)
     for fnc in self.onUriParametersChanged:
         fnc(params)