Moodify - Student Engineering Journal

Moodify began as an iOS prototype while I was taking a Special Topics computer science class in early 2025. Later, I rebuilt it as a larger personal iPhone app. The early version asked a simple question: could a mood choice lead to a useful song from the user's own music library? The newer version kept playback inside the app and became more focused on queue behavior, personalization, and explaining why a recommendation changed.

The question I kept coming back to was: how much can an app learn from messy listening behavior without pretending it knows exactly how someone feels?

About the early dates

I looked back through an older Xcode archive, source-code headers, file dates, and dated screenshots to organize the 2025 entries. I cross-checked them with each other and only included files and screenshots that clearly matched the work from that time, so the timeline is as accurate as possible.

The 2026 entries come from the newer project's git history, and I grouped related commits when they were part of the same problem.

DateAreaEngineering journal
2025-01-24Initial structure and data modelI created the first model, controller, and view-model files, plus a Core Data MoodEntry and a history view model. I wanted Spotify, mood history, and interface code to stay separate, and I decided that each mood entry should persist after the app closed.
2025-02-01Navigation and history fetchingI added the first tab-navigation files and made mood history load newest-first from Core Data. I also created the default Xcode test targets. The main problem was getting saved data onto the correct managed-object context and then exposing it so SwiftUI could update.
2025-02-10 to 2025-02-12Mood selection, HealthKit experiment, and Spotify stateI started the home screen, built a HealthKit experiment for mindful-session data, and created a Spotify player view model that watched playback state, song information, and album artwork. Both services depended on permissions and asynchronous callbacks, so I had to be careful about when the UI changed.
2025-02-23 to 2025-02-25Spotify login and permissionsI built Spotify response models and worked through the login flow. I requested the scopes needed for playback and library data, and I added logout behavior that removed saved tokens so an old session would not hide a login bug.
2025-02-26 to 2025-02-28SwiftUI session-manager ownershipI hit compiler errors while passing the Spotify session manager into the root SwiftUI view. The SDK object was not itself a SwiftUI view model, so I changed the design so one observable wrapper owned the Spotify objects and was passed through the SwiftUI environment.
2025-03-03App capabilities and HealthKit setupI added the HealthKit entitlement and privacy-purpose strings. Writing the integration code was not enough; the target capabilities and permission descriptions also had to be correct.
2025-03-11 to 2025-03-18Persistence and Spotify servicesI expanded MoodEntry to save the emoji, mood level, genre, track, artist, Spotify URI, cover art, playlist, timestamp, and HealthKit-sync state. I also built Spotify profile, playlist, track, token, pagination, and playback-control code.
2025-05-27 to 2025-05-30Custom mood mappingsI replaced permanently hard-coded mood mappings with a MoodMapping model and editing UI. I stored the nine small settings as encoded JSON in AppStorage, while keeping the growing mood history in Core Data.
2025-06-01Shared app compositionI created one shared Spotify session wrapper, one shared data manager, and one Core Data context at the app level, then injected them into the Home, Entries, and Settings tabs. This kept login state and network work consistent across screens.
2025-06-04Spotify redirect and Now PlayingI registered the moodify:// URL scheme, handled the return from Spotify login, and built a Now Playing screen with artwork, song details, duration, and a Play on Spotify action. I also added a fallback so the screen would not fail when a matching track was unavailable during development.
2025-06-05Entry management and history chartsI refined the emoji grid, Settings, saved-entry list, and history dashboard. I grouped entries by calendar day and by emoji, then converted those groups into small models for Swift Charts.
2025-06-06Dynamic mood mappingsI finished a screen where each of nine moods could be mapped to a genre from the user's Spotify data. Because the screen could load before the network request finished, I showed fallback genres first and replaced them when the live list became available.
2025-06-08Concurrent genre collectionI collected genres for every artist on a track using a DispatchGroup, combined them in a Set, and protected the shared set with a serial queue because several callbacks could finish at once.
2025-06-11End-to-end V1 workflowI connected mood selection to genre lookup, track filtering, fallback selection, Core Data saving, and the Now Playing sheet. The school-project version could take a mood, choose a Spotify-library recommendation, save the mood/music pairing, and show history and statistics.
2025-06 to 2026-03Gap before the newer versionThe saved development history has a gap here. The next major direction change appears in March 2026, when MusicKit made it possible to keep Apple Music playback inside Moodify.
2026-03-15V2 rebuild with MusicKitI started a newer version so mood choice, recommendation, playback, and feedback could stay inside one app instead of handing the user off to Spotify.
2026-03-21Apple Music onlyI removed Spotify from the newer version and made Apple Music the only provider. Supporting two providers no longer made sense when only one supported the integrated playback loop I was building.
2026-04-21Beta analytics and listening signalsI added a small Mixpanel analytics service and began tracking session starts, skips with listening position, song completions, and explicit likes or dislikes. I wanted a way to study patterns across real listening sessions instead of depending only on what testers remembered to tell me. These actions still did not have one automatic meaning. A quick skip could suggest something different from a skip near the end, so I treated the analytics as evidence to investigate rather than a simple good-or-bad score.
2026-04-22 to 2026-05-02Expanding the TestFlight betaI uploaded the first internal TestFlight build on April 22 for family and engineering testers. Build 115, uploaded on May 2, was also made available to an external Friends group. Moving beyond testing on my own device gave me real listening sessions and behavioral signals to inspect. Watching my mom use the beta, I noticed that even though she wanted music to fit her mood, she still browsed a lot before finding what felt right. That made me question whether the app should always make someone name a mood before listening. I also learned to separate group access from actual use, so I looked at installs, sessions, feedback, and Mixpanel events instead of treating the number of invited testers as engagement.
2026-05-05 to 2026-05-11Session navigation and Now Playing stateI fixed previous/next oscillation, swipe cards disappearing, artwork identity mistakes, snap-back flashes, and layout problems. I first treated many of them as animation bugs, but they kept pointing back to unclear boundaries between browsing, confirmed playback, and cleanup timing.
2026-05-16 to 2026-05-19Queue backfill and artwork identityI started Apple queue backfill earlier, showed progress, prevented some navigation reactions to temporary pauses, and froze outgoing artwork while the real player settled. Queue timing changed what the user saw, so it could not stay hidden as an internal detail.
2026-05-24Mood mappings and recommendation testsI added multiple genres per mood and tests for repeated songs and artists. One genre per mood felt too narrow, and a queue could feel broken even when it technically returned music.
2026-05-25Media ownership and lifecycleI kept media ownership until the session explicitly ended and tightened background, lock-screen, and remote-control behavior. I learned that iOS media behavior depends on which part of the app owns the session, not only whether the play button works.
2026-05-26Safer refactoringI added boundary checks, behavior tests, one clearer path for playback commands, and smaller testable pieces for queue and recommendation logic. I wanted risky changes to be guided by tests instead of memory.
2026-05-27Playback truth and learning signalsI made the session model follow what Apple Music was actually playing, cleaned up skip/completion/listen-depth processing, and made logs easier to search.
2026-05-31 to 2026-06-07Data cleanup and remote playbackI guarded duplicate mood ordering, separated starting mood definitions from learned profiles, and added AirPods and Siri playback support that still needs real-device testing.
2026-06-28 to 2026-07-05Mood Vector and inspectable personalizationI added an experimental song mood vector, personal adjustments, inspection views, recommendation explanations, and a newer CloudKit record structure. I treated the vector as one scoring signal, not proof that the app understood emotion.
2026-07-06 to 2026-07-07Queue controls and recommendation diagnosticsI blocked controls during unstable queue boundaries, handled pending advances after backfill, treated equivalent playable IDs as the same track when needed, and added recommendation outcome exports. I wanted to inspect what the recommender did instead of judging it only by whether one song felt right.
2026-07-19Product measurementI rebuilt the Mixpanel dashboard around three questions: does Moodify find a fitting song quickly, learn from repeated mood sessions, and bring listeners back? I also added an engagement funnel for app use, session depth, and return frequency. The new analytics are live, but more data and a few tracking improvements are still needed before drawing conclusions.
2026-07-24 to 2026-07-28Comparing repeated mood sessionsI added a same-mood session counter so I could compare a first, second, and later session instead of mixing them together. I also improved playback and personalization reliability and saved more context behind the experimental emotional-index chart so older points could be rebuilt and grouped more clearly. The goal was to make changes easier to inspect, not to claim the chart directly measures emotion.
2026-08-02Starting music without forcing a mood labelI came back to what I had noticed while my mom was beta testing: sometimes listening helps someone figure out what fits instead of the other way around. I added a “Just Play” option so the app can start from a private learned guess without forcing a mood label first. It keeps that guess separate from explicit mood history so it does not silently turn an inference into a fact. I also added a dedicated mood-grid editor and one clearer status flow for preparing, playing, refilling the queue, or ending a mix. This made the app more flexible without weakening the meaning of user-chosen moods.
2026-08-02 to 2026-08-03Mood cloud home and in-session tuningI replaced the old stacked home dashboard with a rotatable mood cloud so choosing music feels less like filling out a form. Recent listening patterns can change which mood is emphasized, but the user still decides what to play. I also moved skip-based refinement into a small “Tune this mix” sheet and tightened session and playback state so an active mix can adjust more reliably. I added reduced-motion and accessibility behavior, but I still need more real-device and tester feedback on the new interaction.
2026-08-04Safer personalization updatesI tightened what happens after someone tunes a mix so one refinement is handled as a single transaction. Moodify now keeps the previous state and can roll back if a write fails instead of leaving the session partly updated. I also reduced duplicate analytics and CloudKit writes, batched record updates, and split some large preference and view-model code so the interface does less work during playback. The new tests cover successful updates and rollback paths, but I still need more real-device sessions to confirm the performance and sync changes under normal use.
2026-08-05Keeping automatic guesses from teaching themselves too stronglyMagic Wand can begin with a mood that Moodify inferred, but I did not want the app's own guess to become as strong as a mood someone chose directly. I separated explicit, inferred, and unattributed learning, capped inferred evidence at half the strength of explicit evidence and then scaled it by confidence, and made the explanation screen say when a mix began from a hypothesis. I also added tests comparing explicit and inferred learning. This lets automatic sessions learn cautiously without turning Moodify's guess into a fact.
2026-08-07 to 2026-08-08Making listening evidence easier to trust and inspectI fixed two measurement problems before relying on the new charts. A skip or completion can arrive after Apple Music has already moved to the next track, so I kept the outgoing recommendation impression long enough to attach the outcome to the right song. I also started separating same-day, 1–7 day, and later returns instead of treating every repeat session the same. Then I moved mood-match, emotional-index, and recommendation-outcome views into a dedicated Mood Insights screen instead of leaving several analytics cards on Home. The tests cover attribution and saved return windows, but I still need real beta data before saying the recommender or retention improved.
2026-08-08Smoother artwork transitions and bounded image cachesI found that Now Playing could replace artwork while a swipe was already leaving the screen, which made the transition hitch even when playback was correct. I changed the outgoing card to use only captured or same-track artwork, lined up the committed artwork reveal with the swipe timing, and added count and memory limits to decoded artwork caches. I added tests for the transition timing and cache-cost calculation, but I still need longer real-device sessions to see how much this helps under normal use.
2026-08-09Optional Apple Health State of Mind loggingI brought an Apple Health idea from the early Moodify prototype into the current app using State of Mind. Moodify can save a reflection only when I explicitly choose or confirm a mood; inferred or Just Play moods are not written to Health. I kept the mood-to-Health mapping conservative and inspectable, added permission, opt-in, failure, and duplicate-save handling, and validated the write flow on a real device. The goal is to make reflection easier without turning Moodify's own guesses into health facts.
2026-08-10Keeping a reset from coming back after cloud syncI found that clearing a learned mood profile on one device could be undone when an older cloud copy merged back in. I added timestamped reset markers so an intentional reset wins over older learning, while genuinely newer learning can retire the marker. I updated the newer cloud-sync format and added tests for reset-only snapshots and local/cloud merge cases. This is a reliability fix, not a claim that the personalization itself got better.
2026-08-12Keeping Home responsive and fallbacks playableI found that Home was re-reading more history and recommendation state than it needed, so I bounded the Core Data history fetches, cached the learning snapshot, and moved the automatic listening fallback away from the main actor. Then I fixed a refresh case that could briefly erase a still-valid Magic Play suggestion and made the Siri fallback reject placeholder tracks that could not actually play. I added tests around the date window, preserved suggestion, and fallback selection. These changes are about responsiveness and failure handling; they do not show that the recommendations themselves got better.
2026-08-14 to 2026-08-15Making Siri start Magic Play more reliablySiri playback had grown through several paths, and I found that a voice command could still hit an empty library or trigger large MusicKit queue updates that briefly interrupted audio. I changed the main voice shortcut to start Magic Play directly, kept older Siri media requests routed into the same playback handler, waited for a playable library before using a fallback, and limited the live Apple Music mirror to a small protected window that only refills near the end. I also made failures visible instead of treating every command like success and added tests around the queue window and refill rule. This is a playback and reliability change; I still need more real-device Siri and AirPods use before calling the voice flow reliable.
2026-08-15Connecting mood-specific Siri requests to synced personalizationAfter getting Magic Play to start more reliably, I wanted Siri to carry a little more structure than just “play something.” I added one request model for current mood, desired mood, energy, or activity and routed both App Intents and older Siri media requests through it. I also made the interaction profile part of Moodify's persisted learning snapshot, bounded its history, merged it across local and cloud copies, and rebuilt derived counts from the durable history. Tests cover mood routing, successful and failed interactions, stale snapshots, and partial-device merges. This connects voice requests and personalization more cleanly, but it does not prove Siri recognition, cross-device sync, or the recommendations are better yet; I still need real-device and multi-device validation.
2026-08-16Choosing the name OndaWhen I restarted Moodify in early 2026, the name was not yet an issue. Recently, as I prepared the app for the App Store, I needed a new customer-facing name. I chose Onda because “onda” means “wave” in Spanish and “온다” means “is coming” in Korean. Together, it felt like “a wave is coming” or “my music vibe is coming,” which fit the project better than a random replacement name.
2026-08-16 to 2026-08-17Giving Onda its own LibraryAt the same time, I separated “saved in my app” from “saved in Apple Music.” I added an Onda Library with its own tab, Core Data-backed saved songs, a first-run import path, search and sorting, and an optional setting to mirror Onda saves into Apple Music. Then I made startup prefer the local saved-song pool, kept catalog and artwork identity more durable, filtered songs that could not actually play when the Apple Music app was unavailable, and allowed careful recovery when the protected MusicKit queue ran out. I also reverted one queue-backfill change when it was not stable enough. This makes ownership and playback boundaries clearer, but I still need longer real-device testing, and it does not show that recommendations are better.
2026-08-18Making Onda Library the real playback boundaryAfter giving Onda its own Library, I found that the app could still act ready before Apple Music access and the saved library were actually usable. I added explicit states for authorization, subscription, library loading, setup, and ready, and I stopped mood playback until Onda Library has at least one saved song. I also added a Recently Listened view backed by persisted playback records and included those records in local fallback recovery so recent history is not silently lost during store reconciliation. This makes the Library feel more like part of the app's playback state instead of just a saved-song screen, but I still need longer real-device and multi-device use before calling the new flow reliable.
2026-08-19Making first-run Library failures recoverableAfter making Onda Library part of playback readiness, I found that first run still had two bad failure modes: the app could hide a failed library load behind a generic setup state, and fallback recovery could restore listening history without restoring the saved library itself. I made library hydration distinguish retryable and unavailable failures, added clear retry and Settings paths, kept first-run setup from appearing until Apple Music and the library are actually ready, and extended local fallback recovery to include Onda Library items and metadata without re-importing duplicates. This is recovery and first-run reliability work; I still need longer real-device and multi-device testing before calling the Library recovery path reliable.
2026-08-20Making startup and playback state tell the truthI rebuilt first run so Onda checks whether an iCloud backup exists before choosing between restore, local-only, or fresh setup, and I kept Apple Music setup from appearing until the saved library has actually resolved. I also made recovery status messages lead to the right place instead of only describing a problem. On playback, I changed queue moves so Onda does not commit a Next or Previous transition until Apple Music confirms that the physical player really moved, and I moved song-pool composition off the main actor so refreshes do less work in the UI path. Tests cover the new first-run choices and queue-transition rules. This is state and recovery work, not proof that startup or playback is fully reliable yet; I still need longer real-device and multi-device use.
2026-08-22Keeping the recommender from getting stuck on one artistI found two ways the ranking could give a misleading result even when the scores looked reasonable. A queue could still bunch too many songs from one artist together, and decaying old listening evidence was also updating the song's last-interaction time, which could make old behavior look recent. I added an artist-balancing pass that uses reserve candidates when one artist dominates, separated the decay checkpoint from real interaction time, and added tests including older saved behavior that does not have the new checkpoint yet. I also tightened the weekly insight rule so a clear overall direction stays the headline even when the week has a few reversals. These changes make the recommendation state more internally consistent, but they do not prove the music feels more diverse or better yet; I still need real listening sessions to judge that.
2026-08-27Keeping listening behavior separate from direct feedbackWhile checking the recommendation analytics, I realized I was mixing two different kinds of evidence. Finishing or skipping a song says something about listening, but tapping Like or Dislike is a direct answer, and one should not erase the other. I split listening outcomes from explicit feedback, kept a song that had already been mostly listened to from being reclassified just because playback stopped later, and made Insights wait for enough samples before saying a mood is working well or needs tuning. I also fixed Previous so reaching the right song while paused no longer gets reported as if it were already playing. Tests cover the new outcome separation and small-sample rules. This makes the app's evidence and playback state more honest, but it still does not prove the recommendations are better; I need more real listening data.
2026-08-28Making important choices reachable with accessibility settingsWhile testing first run, I realized some of the screens where a person makes the most important choices—restore a backup, share analytics, connect Apple Health, or tune a mix—could become hard to use at very large text sizes. I made those flows scroll instead of clipping, let the tuning choices switch to a one-column layout for accessibility text sizes, and made guide animations respect Reduce Motion. I added UI and unit tests at accessibility text sizes and for the motion policy. This makes those choices more reachable in the tested cases, but it is not a full accessibility audit; I still need VoiceOver and real-device testing across the rest of the app.
2026-09-05 to 2026-09-06Making data reset work even when iCloud is offI found that deleting Onda data could get stuck behind iCloud even when sync was turned off, and a stale or failed history load could leave the Library showing the wrong thing. I changed reset so a local deletion can finish immediately while saving a pending marker to carry the deletion into iCloud before sync is used again, added merge and reconciliation tests so an older cloud copy does not silently restore deleted data, gave failed Recent Listening loads an explicit retry, and made loaded history refresh after reset purges remove stale records. Tests cover local-only resets, cloud reconciliation, failed reads, cached rows, large-text and dark-mode retry, and post-reset refresh. This makes deletion and recovery more consistent in code, but I still need longer multi-device and offline-to-online real-device testing before calling the reset flow reliable.
2026-09-16Reducing short-window repeats with confirmed listening historyI found a concrete failure in the recommender: with a stable pool, it could keep choosing the same tracks on consecutive days even when similarly qualified alternatives were available. I added a 72-hour view of confirmed listening starts and use it to prefer less-recent alternatives without changing the learned preference scores themselves. I also rotate oversized saved-song pools so the same prefix does not permanently crowd out the rest of the library. In controlled authored tests, the baseline repeated the same eight tracks across seven days, while the new selection spread choices across more tracks; follow-up tests cover confirmed starts without inventing completions, simultaneous moods, exclusions, source balance, and reset generation. This shows that the repeat-protection mechanism works in the tested fixtures, not that listeners prefer the recommendations. Deliberate replays and real-listener quality still need separate validation.
2026-09-20Keeping learning and discovery evidence honestI found two places where correct-looking totals hid a bad result. The same natural-completion event could update personalization twice even though the stored listening outcome was already deduplicated, and a large Apple Music response could stop mood-specific search even when every returned track was excluded or duplicated. I made the controller claim each completion event before learning from it, while still allowing a later real replay to learn through its new event ID. I also changed discovery to count usable, identity-deduplicated candidates instead of raw rows. Focused authored simulator tests reproduced both failures before the fixes, then passed with the fixes and release simulator builds. I did not test physical Apple Music timing or provider latency, so this improves internal correctness without proving better recommendations.
2026-09-26Giving each automatic playback request its own resultI found that a failed Siri or automatic playback request could borrow unrelated session or error state from another operation. I stopped new failed requests from claiming a session that never started, and I made busy or stale requests return their own explanation while preserving shared playback state. Focused simulator tests covered failed and successful persistence, busy preparation, stale requests, reloads, and existing Siri routing; release simulator builds also passed. Physical Siri speech, competing playback, and recovery after every stale state remain unverified.
2026-10-20Keeping newer Library refreshes from being overwrittenI found that when two Library reloads finished out of order, the older one could replace a newer song list or show an error after a successful refresh. I gave each reload its own request identity and let only the newest accepted request publish its result, while obsolete import callbacks are rejected before taking ownership. Matched simulator checks reproduced stale success and stale error behavior, then verified the fix, the real Try Again path, and an accessibility text-size case; six focused unit tests and a Release simulator build also passed. This is source code only, not an App Store or TestFlight release, and I have not validated it on a physical device.
2026-10-21Keeping Recent Listening on the newest refreshI found that overlapping history reloads could finish out of order, so an older result could replace newer listening history or show an obsolete error after a successful refresh. I gave each reload its own request identity and let only the newest request publish its rows, error, and loading state, while scheduled refreshes clean up only their own work. Focused tests reproduced stale success, stale error, and scheduled-settlement failures before the change; seven tests passed with the fix, and matched simulator checks verified the visible results and the real Try Again recovery path. A Release simulator build also passed. This is source code only, not an App Store or TestFlight release, and I have not validated it on a physical device.
2026-10-21Finishing a data reset after an interruptionI found that if an all-data reset was interrupted after Onda recorded the reset but before it cleared personalization, reopening the app could leave old learned profiles behind. I changed recovery to decide whether cleanup finished from the persisted preference snapshot, so a pending reset clears old learning while an already-completed reset preserves learning added afterward. Focused tests reproduced the interrupted failure, then 21 reset and history tests passed with controls for later learning, library-only resets, and learned interaction data; a Release simulator build also passed. This is source code only, not an App Store or TestFlight release. I have not validated OS-level crash recovery or this flow on a physical device.
2026-11-01Making failed Apple Health mood saves recoverableA selected mood could fail to save to Apple Health without a clear way to fix that entry. In the source, a notice now explains the failure and offers Retry or Dismiss; retry keeps the same mood, timestamp, and entry ID rather than making a new log or starting music again. Denied or unsupported saves show guidance instead of an inappropriate retry. Twenty controller tests and four scoped simulator UI checks passed, including larger text and content reachability. This is source code, not a TestFlight or App Store update; live Health writes and physical-device accessibility still need testing.
2026-11-01Recovering when Apple Music access is missingMissing Apple Music access could leave too much of the app blocked instead of showing how to continue. The source now keeps Home available, explains what is missing, lets someone Check Again, and can open Apple's subscription option when eligible. Library setup still needs an explicit Continue, and an old playback choice does not start on its own after access returns. Fifty-five focused tests and eight scoped simulator UI cases passed. The native subscription sheet, purchases, full production Home layout, and physical-device accessibility are not yet verified. This is not a new store release.
2026-11-01Recognizing a recent song across catalog IDsA song played in one session could look new later if catalog enrichment changed its main ID, even though the saved track ID still matched. The source now checks directly shared, normalized track identifiers in confirmed listening history, within the existing 72-hour window, instead of guessing from song titles or merging recordings. Thirteen current integration/controller tests and a Release simulator build passed; earlier repository controls were also retained. This is a bounded fix in source, not proof that real listeners hear fewer repeats or that Apple Music playback on a device was tested.
2026-11-06Reducing repeat openers from HomeI confirmed that the same opening song could play again after relaunch, then found a separate gap in the current Home path: it chose the first song without consulting Onda's confirmed listening history. In fixed-candidate regression tests, that omission allowed the previous opener to be selected again. I changed both Magic Play and explicit mood starts on Home to wait for that history, then use the existing recency rule while keeping deliberate resume and replay behavior separate. A scoped simulator suite passed 1,027 tests with no failures, and a signed device check chose and played a different opener after relaunch while preserving mood labels, resume position, the portrait layout, and side tabs. A limited candidate pool can still allow repeats, and the short check does not prove an overnight improvement or an App Store release.
2026-11-06Making Library setup and removal failures recoverableI found two Library paths that could leave someone stuck: the first setup screen could crash because it was missing an existing recovery dependency, and a failed swipe to remove could keep the song without explaining what happened. I passed the existing recovery controller into setup, then made removal failures keep the saved song, show a clear retry message, and keep that recovery inside Library instead of sending someone to unrelated Apple Music settings. A successful retry removes the song without clearing a newer unrelated error, and search restores the same query when reopened. Two isolated setup UI checks and a dedicated 34-test removal recovery run passed in the simulator. The removal failure used an injected repository and was not reproduced from real customer storage. Its recovery has no physical-device, VoiceOver, dark-mode or full-suite validation, and neither change is a TestFlight or App Store release.
2026-11-07Protecting a newer reset from older cloud workI reproduced a race where a cloud response that began before Clear Onda Library could return later, restore an older reset generation, and delete a song saved after the reset. I kept reset and reconciliation mutations in one ordered path and reject older responses once a newer reset owns the state. Twenty-nine focused reset and history tests and a Release simulator build passed. The tests used injected cloud responses and in-memory storage; I did not run a destructive reset against a real CloudKit account or physical phone, and this is not a store release.
2026-11-07Making Home motion, accessibility and song changes easier to followI made the mood cloud respond to vertical and diagonal drags, removed unnecessary waiting before Magic Play begins, and kept Magic preparation owned by the current request so a drag or mood choice can cancel it without stale work taking over. At large text sizes, the status message now scrolls inside a bounded area with separate recovery and close controls, while Magic and the mood cloud remain reachable. I also fixed a Now Playing handoff where the previous album image could return briefly after a song flip. Focused simulator checks passed for motion, Magic ownership, large-text layout and artwork handoff; the Home flow was exercised on a wired iPhone, and the installed artwork fix was confirmed by the user. Actual VoiceOver focus and speech, matched energy or hitch measurements, physical-device large-text coverage, and comprehensive live Apple Music failure testing remain incomplete. These changes are source code, not a new TestFlight or App Store release.
2026-11-08 to 2026-11-09Controlling Onda from the Home Screen and SiriI added an interactive Home Screen widget that shows the current song and can start a mood or Magic, pause or resume, move between tracks, and record feedback without opening the app. I kept the app's existing playback and learning components in charge so the widget is another control surface rather than a second music engine. I also repaired background Siri requests that could lose their action during startup, and let an automatic recommendation skip a few unavailable catalog choices without retrying network, authorization, or an explicitly requested song. Forty-one focused widget and reset tests passed, both device and simulator builds succeeded, and physical iPhone checks exercised cold-start Magic plus warm mood, transport, and pause actions while Home stayed visible. Those checks did not separately execute the final Siri change. One physical Next request still cancelled before advancing, and force-quit behavior, VoiceOver, pressed feedback, and every live failure path remain incompletely verified. This is implemented source work, not an App Store release; the final combined behavior has not been validated as one TestFlight build.
2026-11-09Remembering when I reject a songA Dislike did not create a durable rule to keep that recording out of later automatic choices, so it could return in another mood or Magic session. I added an explicit song preference to the saved personalization snapshot and cloud merge, then filter rejected recordings from automatic recommendations, queue backfill, and Siri fallback. A later Like can reverse the choice, passive listening does not undo it, and deliberate replay from Recent Listening remains allowed. Reset ownership also keeps delayed feedback or cloud work from restoring an old rejection after a reset. The source adds regression coverage for catalog aliases, later Likes, cloud round trips, reset races, and exhausted candidate pools, but I found no recorded executed test run, simulator or physical-device check, or TestFlight or App Store release for this commit.
2026-11-14Retrying a transient Apple Music access failure during background playbackI found that a widget or other background playback request could stay blocked after Apple Music access failed once, even if the next request might succeed without reopening the app. I changed background preparation so a new request can retry a failed capability check, while denied or disconnected access does not retry, duplicate requests share the same refresh, and cancelled or obsolete work cannot publish a late success. I added focused tests for recovery, repeated failure, timeouts, cancellation, disconnection, and concurrent retries. I have not recorded a physical-device or live Apple Music validation run for this change, and the later version bump to 1.26 does not by itself prove a TestFlight or App Store release.
2026-11-15 to 2026-11-16Keeping song sequences varied and resumed playback in syncI found two ways a mix could feel less trustworthy even when Apple Music was still working. Queue batches and refills could place the same artist back to back despite a suitable alternative, and resuming paused playback could invalidate callbacks from the existing Apple queue so a later advance was ignored by Onda. I changed sequencing to spread artists when it can do so without weakening mood fit, rejection, recency, or source rules. Separately, I kept the existing queue identity when playback resumes while discarding an older in-flight resume or fallback after a newer queue takes ownership. Focused simulator suites passed for artist ordering and refill boundaries, including scarce pools where repeats are unavoidable, and signed builds succeeded. A broader ordering run was not clean because separate reset checks failed and the run was interrupted. The final resume patch adds regression tests, but I found no recorded executed run for them. An installed Stage 1a Release build did not confirm playback and the cause was unknown; later device work for a separate familiarity check did not validate artist ordering or the resume fix. Physical acceptance, live catalog quality, and evidence that listeners prefer the order remain unverified. This is source code, not a TestFlight or App Store release.
2026-11-17Restoring saved playback with its original song identityI found a second resume boundary after the live queue fix: the lightweight session snapshot kept a title and playable identifier but dropped the Apple Music catalog ID and duration. After an app restart, restoring that snapshot could therefore rebuild a weaker version of the song even though Onda had already known its catalog identity and timing. I saved both fields and kept the decoder compatible with older snapshots, so a restored session reconstructs the same playback identity and duration when they were available. The source adds regression tests for library and catalog identifiers and the older snapshot format, but I found no recorded executed test, simulator run, physical-device playback check, or TestFlight or App Store release for this commit. The effect on live Apple Music resume still needs device validation.

Looking back

The 2025 version taught me how much work sits behind a simple interaction. Choosing an emoji and receiving music required OAuth redirects, permissions, asynchronous networking, pagination, shared SwiftUI state, persistence, and fallbacks.

The newer version changed the problem. Once playback stayed inside Moodify, most of the difficult work became state, timing, and interpretation. A lot of progress came from trying a direct fix, finding another edge case, adding logs or tests, and then making the structure clearer. Family and friends are now testing the app on their own devices, but I still need more coverage for edge cases around Apple Music, AirPods, Siri, and CloudKit.