private void parse_delivery_state(IPod pod, byte delivery_state) { if ((delivery_state & 8) > 0) { pod.BolusState = BolusState.Extended; } else if ((delivery_state & 4) > 0) { pod.BolusState = BolusState.Immediate; } else { pod.BolusState = BolusState.Inactive; } if ((delivery_state & 2) > 0) { pod.BasalState = BasalState.Temporary; } else if ((delivery_state & 1) > 0) { pod.BasalState = BasalState.Scheduled; } else { pod.BasalState = BasalState.Suspended; } }
public void RegisterPod(IPod podPublisher, int podId) { PodPublisher pod = (PodPublisher)podPublisher; pod.PodPropertyChangedEvent += HandlePodDataChange; Id = podId; }
/// <inheritdoc /> public void Process(IPod pod) { _executionContextManager.CurrentFor(pod.Metadata.Tenant); if (pod.IsDeleted) { _logger.Information($"Build-pod '{pod.Metadata.ToString()}' is deleted."); return; } if (!pod.HasBuildContainerStatuses) { _logger.Information($"Build-pod '{pod.Metadata.ToString()}' has no statuses to process."); return; } if (pod.HasSucceeded) { _logger.Information($"Build-pod '{pod.Metadata.ToString()}' succeeded."); ProcessSteps(pod); pod.Delete(); return; } else if (pod.HasFailed) { _logger.Warning($"Build-pod '{pod.Metadata.ToString()}' failed."); pod.Delete(); return; } _logger.Information($"Build-pod '{pod.Metadata.ToString()}' still in progress."); ProcessSteps(pod); }
public DeleteContentOperation(IPod dev, Playlist pl, IEnumerable<Track> tracks, bool isAltMode) : this(dev, isAltMode) { _playList = pl; _tracks = tracks; }
public DeleteContentOperation(IPod dev, IEnumerable<Playlist> playlists, bool isAltMode) : this(dev, isAltMode) { _playList = null; _playlists = playlists; }
public static IPod CreatePod() { IPod pod = null; try { string podSelection = ConfigurationManager.AppSettings["podSelection"]; podSelectValue = int.Parse(podSelection); } catch (Exception ex) { Console.WriteLine("Consumer - Error getting pod selection: {0}", ex.Message); return(null); } switch (podSelectValue) { case 1: pod = new Pod(); pod.Name = "PodSelected"; break; case 2: pod = new PodSubscriber(); pod.Name = "PodSubscriberSelected"; break; case 3: pod = new PodPublisher(); pod.Name = "PodPublisherSelected"; break; } return(pod); }
public CopyContentFromSelfOperation(IPod dev, IEnumerable<Track> tracks, string destination, bool isMove, bool directCopy) : this(dev, destination, isMove) { _tracks = tracks; _directCopy = directCopy; }
private void AddDevice(IPod.Device device) { ArrayList tracks = new ArrayList (); ArrayList playlists = new ArrayList (); foreach (IPod.Track itrack in device.TrackDatabase.Tracks) { Track track = AddTrack (itrack); if (track != null) tracks.Add (track); } foreach (IPod.Playlist ipl in device.TrackDatabase.Playlists) { playlists.Add (AddPlaylist (ipl)); } foreach (IPod.Playlist ipl in device.TrackDatabase.OnTheGoPlaylists) { playlists.Add (AddPlaylist (ipl)); } trackHash[device.VolumeId] = tracks; playlistHash[device.VolumeId] = playlists; devices.Add (device); log.InfoFormat ("Added device '{0}'", device.Name); }
void ProcessSteps(IPod pod) { var tracker = _getTracker(); pod.Statuses.ForEach(_ => tracker.Track(_)); _handleBuildSteps.Handle(pod.Metadata, tracker); }
protected OnDeviceOperation(IPod dev) { device = dev; isWriteMode = false; notProcessedItems = new List<object>(); }
public CreatePlayListOperation(IPod dev, string name, PlaylistSortField sortField) : base(dev) { _name = name; _sortField = sortField; isWriteMode = true; }
public DirectPlaylistOperation(IPod dev, Playlist pl, string newName, PlaylistSortField sortField, bool isMove) : base(dev) { _playList = pl; _newName = newName; _newSortField = sortField; _isMove = isMove; isWriteMode = true; }
private CopyContentFromSelfOperation(IPod dev, string destination, bool isMove) : base(dev) { _destination = destination; isMoveOperation = isMove; isWriteMode = isMove; setText(MsgStr.MsgCopyOrMoveToPath); }
private DeleteContentOperation(IPod dev, bool isAltMode) : base(dev) { _isAltMode = isAltMode; // ??? isWriteMode = true; setText(MsgStr.MsgDelete); }
private void parse_resync_response(IPod pod) { if (PartData[1] == 0x14) { pod.NonceSync = PartData.Word(2); } else { throw new OmniCoreException($"Unknown resync request {PartData} from pod"); } }
public void Eject(IPod dev) { ProgressFormHelper.Invoke( f => dev.Eject(), MsgStr.MsgEjecting); if (_deviceList.Contains(dev)) { _deviceList.Remove(dev); } }
public TrackTagEditDialog(IPod dev, List<Track> trackList) : this() { _trackList = trackList; _itemCount = trackList.Count; _device = dev; _device.AssertIsWritable(); _device.AcquireLock(); }
private void parse_information_response(IPod pod) { int i = 1; var rt = PartData.Byte(i++); switch (rt) { case 0x01: pod.AlertW278 = PartData.Word(i); i += 2; pod.AlertStates = new ushort[] { PartData.Word(i), PartData.Word(i + 2), PartData.Word(i + 4), PartData.Word(i + 6), PartData.Word(i + 8), PartData.Word(i + 10), PartData.Word(i + 12), PartData.Word(i + 14), }; break; case 0x02: pod.LastUpdated = DateTime.UtcNow; pod.Faulted = true; pod.Progress = (PodProgress)PartData.Byte(i++); parse_delivery_state(pod, PartData.Byte(i++)); pod.NotDeliveredInsulin = PartData.Byte(i++) * 0.05m; pod.MessageSequence = PartData.Byte(i++); pod.DeliveredInsulin = PartData.Byte(i++) * 0.05m; pod.FaultCode = PartData.Byte(i++); pod.FaultRelativeTime = PartData.Word(i); pod.Reservoir = PartData.Word(i + 2) * 0.05m; pod.ActiveMinutes = PartData.Word(i + 4); i += 6; pod.AlertMask = PartData.Byte(i++); pod.TableAccessFault = PartData.Byte(i++); byte f17 = PartData.Byte(i++); pod.InsulinStateTableCorruption = f17 >> 7; pod.InternalFaultVariables = (f17 & 0x60) >> 6; pod.FaultedWhileImmediateBolus = (f17 & 0x10) > 0; pod.ProgressBeforeFault = (PodProgress)(f17 & 0x0F); byte r18 = PartData.Byte(i++); pod.RadioLowGain = (r18 & 0xC0) >> 6; pod.RadioRssi = r18 & 0x3F; pod.ProgressBeforeFault2 = (PodProgress)(PartData.Byte(i++) & 0x0F); pod.FaultInformation2LastWord = PartData.Byte(i++); break; default: throw new OmniCoreException($"Failed to parse the information response of type {rt}"); } }
public CopyContentToSelfOperation(IPod dev, IEnumerable<string> files, string source, string targetPlayName, bool isMove) : base(dev) { _files = files; _source = source; _targetPlayListName = targetPlayName; isMoveOperation = isMove; isWriteMode = true; setText(MsgStr.MsgCopyOrMoveToDevice); }
public PodCommandResult ParseResponse(IMessage response, IPod pod) { foreach (var mp in response.GetParts()) { var er = mp as ErosResponse; er.Parse(pod); } return(new PodCommandResult() { }); }
public void RegisterPod(IPod podPublisher, int podId) { // ((PodPublisher)podPublisher).PodPropertyChangedEvent += HandlePodDataChange; var pod = podPublisher as PodPublisher; if (pod != null) { pod.PodPropertyChangedEvent += HandlePodDataChange; } else { throw new NullReferenceException("Failed to get a valid publisher", new Exception()); } Id = podId; }
private void parse_status_response(IPod pod) { pod.LastUpdated = DateTime.UtcNow; var s0 = PartData[0]; uint s1 = PartData.DWord(1); uint s2 = PartData.DWord(5); parse_delivery_state(pod, (byte)(s0 >> 4)); pod.Progress = (PodProgress)(s0 & 0xF); pod.MessageSequence = (int)(s1 & 0x00007800) >> 11; pod.DeliveredInsulin = ((s1 & 0x0FFF8000) >> 15) * 0.05m; pod.NotDeliveredInsulin = (s1 & 0x000007FF) * 0.05m; pod.Faulted = ((s2 >> 31) != 0); pod.AlertMask = (byte)((s2 >> 23) & 0xFF); pod.ActiveMinutes = (uint)((s2 & 0x007FFC00) >> 10); pod.Reservoir = (s2 & 0x000003FF) * 0.05m; }
private void parse_version_response(IPod pod) { bool lengthyResponse = false; pod.LastUpdated = DateTime.UtcNow; int i = 1; if (PartData.Length == 27) { pod.Version7Bytes = PartData.ToArray(i, i + 7); i += 7; lengthyResponse = true; } var mx = PartData.Byte(i++); var my = PartData.Byte(i++); var mz = PartData.Byte(i++); pod.VersionPm = $"{mx}.{my}.{mz}"; var ix = PartData.Byte(i++); var iy = PartData.Byte(i++); var iz = PartData.Byte(i++); pod.VersionPi = $"{ix}.{iy}.{iz}"; pod.VersionByte = PartData.Byte(i++); pod.Progress = (PodProgress)(PartData.Byte(i++) & 0x0F); pod.Lot = PartData.DWord(i); pod.Serial = PartData.DWord(i + 4); i += 8; if (!lengthyResponse) { var rb = PartData.Byte(i++); pod.RadioLowGain = rb >> 6; pod.RadioRssi = rb & 0b00111111; pod.RadioAddress = PartData.DWord(i); } else { pod.RadioAddress = PartData.DWord(i); } }
/// <summary> /// Starts the watcher /// </summary> public void StartWatcher() { // FIXME: This should run all the time, so have a look at what happens on exceptions and when it is closed. The client should possibly be disposed. Task.Run(async() => { var client = _clientFactory(); var watchList = await client.ListNamespacedPodWithHttpMessagesAsync("dolittle-builds", watch: true); watchList.Watch <V1Pod>( // OnEvent (eventType, pod) => { _logger.Trace($"Got event {eventType} for pod '{pod.Metadata.Name}'. The status is {pod.Status.Phase}."); IPod buildPod = null; try { //TODO: create a factory for building the pod buildPod = new Pod(pod, _clientFactory, _metadataFactory); _buildPodProcessor.Process(buildPod); } catch (InvalidImprovementMetadata ex) { _logger.Error(ex, $"Unable to build metadata for '{pod?.Metadata?.Name ?? "[NULL]"}'"); DeletePod(pod); } }, // OnException (ex) => { _logger.Error(ex, "Error while watching list of build pods."); }, // OnClose () => { _logger.Error("Build pod watcher was closed unexpectedly."); } ); }); }
public void Parse(IPod pod) { switch (PartType) { case PartType.ResponseVersionInfo: parse_version_response(pod); break; case PartType.ResponseDetailInfoResponse: parse_information_response(pod); break; case PartType.ResponseResyncResponse: parse_resync_response(pod); break; case PartType.ResponseStatus: parse_status_response(pod); break; default: throw new OmniCoreException($"Unknown response type {PartType}"); } }
public async Task <bool> Save(IPod pod) { throw new NotImplementedException(); }
public async Task <IMessageExchange> GetMessageExchanger(IMessageExchangeParameters messageExchangeParameters, IPod pod, IMessageProgress messageProgress, CancellationToken ct) { if (RileyLinkInstance == null) { RileyLinkInstance = new RileyLink(); } if (RileyLinkMessageExchange == null) { RileyLinkMessageExchange = new RileyLinkMessageExchange(messageExchangeParameters, pod, RileyLinkInstance); } else { RileyLinkMessageExchange.UpdateParameters(messageExchangeParameters, pod, RileyLinkInstance); } await RileyLinkMessageExchange.InitializeExchange(messageProgress, ct); return(RileyLinkMessageExchange); }
public Consumer() { pod = PodFactory.CreatePod(); }
private void RemoveDevice(IPod.Device device) { ArrayList tracks = trackHash[device.VolumeId] as ArrayList; ArrayList playlists = playlistHash[device.VolumeId] as ArrayList; foreach (Track track in tracks) { db.RemoveTrack (track); } foreach (Playlist pl in playlists) { db.RemovePlaylist (pl); } trackHash.Remove (device.VolumeId); playlistHash.Remove (device.VolumeId); devices.Remove (device); log.InfoFormat ("Removed device '{0}'", device.Name); }
public IpodTrackInfo (IPod.Track track) : base () { this.track = track; LoadFromIpodTrack (); CanSaveToDatabase = true; }
internal RileyLinkMessageExchange(IMessageExchangeParameters messageExchangeParameters, IPod pod, RileyLink rileyLinkInstance) { RileyLink = rileyLinkInstance; Pod = pod; MessageExchangeParameters = messageExchangeParameters as ErosMessageExchangeParameters; }
public void UpdateParameters(IMessageExchangeParameters messageExchangeParameters, IPod pod, RileyLink rileyLinkInstance) { RileyLink = rileyLinkInstance; Pod = pod; MessageExchangeParameters = messageExchangeParameters as ErosMessageExchangeParameters; }
private Track AddTrack(IPod.Track itrack) { if (LookupTrack (itrack) != null) return null; Track track = new Track (); db.AddTrack (track); track.Artist = itrack.Artist; track.Album = itrack.Album; track.Title = itrack.Title; track.Duration = itrack.Duration; track.FileName = itrack.FileName; track.Format = Path.GetExtension (itrack.FileName).Substring (1); track.Genre = itrack.Genre; FileInfo info = new FileInfo (itrack.FileName); track.Size = (int) info.Length; track.TrackCount = itrack.TotalTracks; track.TrackNumber = itrack.TrackNumber; track.Year = itrack.Year; track.BitRate = (short) itrack.BitRate; return track; }
// pretty lame, but it should avoid most duplicates private Track LookupTrack(IPod.Track itrack) { foreach (Track track in db.Tracks) { if (track.Title == itrack.Title && track.Size == itrack.Size) { return track; } } return null; }
public async Task <bool> Load(IPod pod) { await Initialize(); return(false); }
public PodSubscriber(IPod podPublisher, int podId) { RegisterPod(podPublisher, podId); }
private void OnDeviceAdded(object o, IPod.DeviceAddedArgs args) { try { AddDevice (new IPod.Device (args.Udi)); server.Commit (); } catch (Exception e) { Daemon.LogError (String.Format ("Failed to add device '{0}'", args.Udi), e); } }
protected string getDeviceName(IPod dev) { return dev.DeviceInfo.Family.ToString(); }
private void OnIpodDatabaseSaveProgressChanged (object o, IPod.TrackSaveProgressArgs args) { double progress = args.CurrentTrack == null ? 0.0 : args.TotalProgress; string message = args.CurrentTrack == null ? Catalog.GetString ("Updating...") : String.Format ("{0} - {1}", args.CurrentTrack.Artist, args.CurrentTrack.Title); if (progress >= 0.99) { sync_user_job.Status = Catalog.GetString ("Flushing to disk..."); sync_user_job.Progress = 0; } else { sync_user_job.Status = message; sync_user_job.Progress = progress; } }
public static bool IsEqualToDevice(this IPod f, IPod s) { return f.DeviceInfo.SerialNumber == s.DeviceInfo.SerialNumber && f.FileSystem.DriveLetter == s.FileSystem.DriveLetter; }
public void CommitToIpod (IPod.Device device) { bool update = (track != null); if (!update) { try { track = device.TrackDatabase.CreateTrack (Uri.AbsolutePath); } catch (Exception e) { Log.Exception ("Failed to create iPod track with Uri " + Uri.AbsoluteUri, e); device.TrackDatabase.RemoveTrack (track); return; } } ExternalId = track.Id; //if the track was not in the ipod already, the CreateTrack(uri) //method updates the Uri property with the path of the new file //so we need to save it on Banshee db to be properly synced if (!update) { Uri = new SafeUri (track.Uri); } track.AlbumArtist = AlbumArtist; track.BitRate = BitRate; track.SampleRate = (ushort)SampleRate; track.BPM = (short)Bpm; track.Comment = Comment; track.Composer = Composer; track.DateAdded = DateAdded; track.TotalDiscs = DiscCount; track.DiscNumber = DiscNumber; track.Duration = Duration; track.Size = (int)FileSize; track.Grouping = Grouping; track.IsCompilation = IsCompilation; track.LastPlayed = LastPlayed; track.PlayCount = PlayCount; track.TotalTracks = TrackCount; track.TrackNumber = TrackNumber; track.Year = Year; track.DateReleased = ReleaseDate; track.Album = AlbumTitle; track.Artist = ArtistName; track.Title = TrackTitle; track.Genre = Genre; switch (Rating) { case 1: track.Rating = IPod.TrackRating.Zero; break; case 2: track.Rating = IPod.TrackRating.Two; break; case 3: track.Rating = IPod.TrackRating.Three; break; case 4: track.Rating = IPod.TrackRating.Four; break; case 5: track.Rating = IPod.TrackRating.Five; break; default: track.Rating = IPod.TrackRating.Zero; break; } if (HasAttribute (TrackMediaAttributes.Podcast)) { track.DateReleased = ReleaseDate; track.Description = description; track.RememberPosition = true; track.NotPlayedMark = track.PlayCount == 0; } if (HasAttribute (TrackMediaAttributes.VideoStream)) { if (HasAttribute (TrackMediaAttributes.Podcast)) { track.Type = IPod.MediaType.VideoPodcast; } else if (HasAttribute (TrackMediaAttributes.Music)) { track.Type = IPod.MediaType.MusicVideo; } else if (HasAttribute (TrackMediaAttributes.Movie)) { track.Type = IPod.MediaType.Movie; } else if (HasAttribute (TrackMediaAttributes.TvShow)) { track.Type = IPod.MediaType.TVShow; } else { track.Type = IPod.MediaType.Video; } } else { if (HasAttribute (TrackMediaAttributes.Podcast)) { track.Type = IPod.MediaType.Podcast; } else if (HasAttribute (TrackMediaAttributes.AudioBook)) { track.Type = IPod.MediaType.Audiobook; } else if (HasAttribute (TrackMediaAttributes.Music)) { track.Type = IPod.MediaType.Audio; } else { track.Type = IPod.MediaType.Audio; } } if (CoverArtSpec.CoverExists (ArtworkId)) { SetIpodCoverArt (device, track, CoverArtSpec.GetPath (ArtworkId)); } }
public CopyContentFromSelfOperation(IPod dev, IEnumerable<Playlist> playlists, string destination, bool isMove) : this(dev, destination, isMove) { _playlists = playlists; }
public BatchTagEditDialog(IPod dev, List<Track> trackList) { _trackList = trackList; _device = dev; }
private Playlist AddPlaylist(IPod.Playlist ipl) { Playlist pl = new Playlist (ipl.Name); foreach (IPod.Track itrack in ipl.Tracks) { Track track = LookupTrack (itrack); if (track != null) pl.AddTrack (track); } db.AddPlaylist (pl); return pl; }
private void OnDeviceRemoved(object o, IPod.DeviceRemovedArgs args) { foreach (IPod.Device dev in devices) { if (dev.VolumeId == args.Udi) { RemoveDevice (dev); server.Commit (); break; } } }
// FIXME: No reason for this to use GdkPixbuf - the file is on disk already in // the artwork cache as a JPEG, so just shove the bytes from disk into the track public static void SetIpodCoverArt (IPod.Device device, IPod.Track track, string path) { try { Gdk.Pixbuf pixbuf = null; foreach (IPod.ArtworkFormat format in device.LookupArtworkFormats (IPod.ArtworkUsage.Cover)) { if (!track.HasCoverArt (format)) { // Lazily load the pixbuf if (pixbuf == null) { pixbuf = new Gdk.Pixbuf (path); } track.SetCoverArt (format, IPod.ArtworkHelpers.ToBytes (format, pixbuf)); } } if (pixbuf != null) { pixbuf.Dispose (); } } catch (Exception e) { Log.Exception (String.Format ("Failed to set cover art on iPod from {0}", path), e); } }
private void SetDetailValue(IPod.DetailType type, string val) { DetailRecord detail = record.GetDetail (type); if (String.IsNullOrEmpty (val)) record.RemoveDetail (detail); else detail.Value = val; }
internal DeviceEventArgs(IPod.Device Device) { _device = Device; }
public MessageHandler(IPod pod, IMessageExchangeProvider messageExchangeProvider) { Pod = pod; MessageExchangeProvider = messageExchangeProvider; MessageSynchronizationContext = new SynchronizationContext(); }
protected CopyContentOperation(IPod dev) : base(dev) { }
public override void Dispose() { if (_currentMediaFile != null) { _currentMediaFile.Dispose(); _currentMediaFile = null; } if (_device != null) { _device.ReleaseLock(); _device = null; } _filesToSave.Clear(); base.Dispose(); }