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();
}
