Fix: Android App Stuck On Splash Screen After Relaunch

by Kenji Nakamura 55 views

Introduction

Hey guys! Ever faced that frustrating moment when your Android app gets stuck on the splash screen? It's like the app is teasing you, showing its face but refusing to fully open. We're diving deep into a specific scenario where this happens in the Expensify app, particularly after relaunching the app when trying to log in via a public room link. This isn't just a minor annoyance; it's a critical issue that can severely impact user experience. Imagine a user clicking on a link to join a public room, getting prompted to sign in, and then… nothing. The app just hangs there, leaving the user stranded. In this article, we'll explore the nitty-gritty details of this bug, its impact, and potential solutions. We'll break down the steps to reproduce the issue, the expected versus actual results, and even look at a workaround (or lack thereof). Whether you're a developer, a QA engineer, or just an Expensify user curious about the inner workings, this article is for you. We're not just highlighting the problem; we're aiming to provide a comprehensive understanding so that it can be tackled effectively. So, buckle up and let's get started on this journey to squash this splash screen bug!

The Bug: A Deep Dive

Okay, let's get into the heart of the matter. The core issue here is that the Expensify Android app sometimes gets stuck on the splash screen after relaunching, specifically when a user attempts to sign in through a public room link. This is more than just a cosmetic glitch; it's a significant roadblock for users trying to access the app's functionality. Think about it: you click on a link, you're ready to jump into a conversation or a task, and bam! You're met with a frozen splash screen. Not the best first impression, right? This bug was identified in version 9.1.89-1 and is reproducible in the staging environment, which is crucial for catching these kinds of issues before they hit the production version. The Applause Internal Team reported it, which means it's been flagged by professionals who are trained to find these kinds of problems. They're using a Samsung Galaxy Z Fold 4 running Android 15, so we have a specific device and OS to consider. This kind of detail is gold when you're trying to replicate and fix a bug. The issue falls under the "Other" app component category, which suggests it might not be directly tied to a specific feature but rather a more general interaction or flow within the app. This makes it a bit trickier to pinpoint, but with the steps to reproduce laid out clearly, we're in a good position to understand what's going on. So, let’s dig into the exact steps that trigger this frustrating splash screen freeze.

Steps to Reproduce the Splash Screen Issue

To really understand this Android app splash screen issue, we need to walk through the exact steps that cause it. It's like a recipe – miss an ingredient or step, and the final dish won't turn out right. So, let's break it down:

  1. Precondition: Make sure the user is logged out. This is the starting point, ensuring we're all on the same page. It's like starting with a clean slate.
  2. Open Public Room via Deep Link: Use a deep link (like the example provided: https://staging.new.expensify.com/r/8833307540863909) to access a public room. Deep links are like shortcuts that take you directly to a specific part of the app.
  3. Tap Sign In on the Bottom Banner: When you open the public room as a logged-out user, you'll see a prompt to sign in. Tap that button.
  4. Kill the App: This is where things get interesting. Force-close the app – basically, shut it down completely. This simulates a user switching away from the app and then coming back later.
  5. Relaunch the App: Now, open the app again. This is the moment of truth. Will it load properly, or will it get stuck?
  6. Repeat if Necessary: Here's the kicker – the issue might not happen every single time. Sometimes, you might need to repeat steps 3 and 4 to trigger the splash screen freeze. It's a bit like a finicky machine that needs a few tries to break down.

These steps might seem simple, but they're crucial for consistently reproducing the bug. By following them precisely, developers and testers can reliably see the issue in action and start working on a fix. It's all about making the bug appear on demand, rather than chasing a ghost. Now that we know how to make the bug happen, let's talk about what we expect to see versus what actually happens.

Expected vs. Actual Results

In the world of software development, understanding the difference between expected and actual results is key to squashing bugs. It's like having a map (the expected result) and realizing you've taken a wrong turn (the actual result). So, let's break down what should happen versus what's actually happening in this splash screen saga.

Expected Result:

The ideal scenario is straightforward: after relaunching the app, it should open normally. No hiccups, no freezes, just a smooth transition back into the app. The user should be able to proceed with the sign-in process without any issues. This is the map we're trying to follow – a seamless user experience.

Actual Result:

Here's where things go off the rails. Instead of a smooth relaunch, the app gets stuck on the splash screen. It's like hitting a wall – the app just hangs there, unresponsive. This is the wrong turn on our map. The user is left staring at the splash screen, unable to proceed. This is not just annoying; it's a complete roadblock. They can't access the app, can't sign in, and can't use any of its features. This is a major usability issue that needs to be addressed.

The contrast between the expected and actual results highlights the severity of the bug. It's not just a minor cosmetic issue; it's a fundamental problem that prevents users from accessing the app. This is why it's crucial to identify and fix these kinds of bugs as quickly as possible. Now that we've clearly defined the problem, let's explore if there's a workaround – a detour that users can take while the developers work on a permanent solution.

Workaround and Platform Impact

When a bug pops up, especially one as disruptive as an Android app getting stuck on the splash screen, the first question on everyone's mind is: Is there a workaround? A workaround is like a temporary fix, a detour around the problem that allows users to continue using the app while the developers work on a permanent solution. Unfortunately, in this case, the workaround is unknown. This means that if a user gets stuck on the splash screen, there isn't a clear, easy way for them to get past it. This makes the bug even more critical because affected users are essentially locked out of the app until a proper fix is implemented.

Platform Impact

It's also crucial to understand which platforms are affected by this bug. In this instance, the issue is confirmed to be reproducible on Android apps. This means that users on Android devices are the ones most likely to encounter this splash screen freeze. The bug report specifically mentions testing on a Samsung Galaxy Z Fold 4 running Android 15, which gives us a concrete device and OS version to focus on. However, it's possible that the bug could affect other Android devices and versions as well. The report also explicitly states which platforms are not affected:

  • Android mWeb Chrome
  • iOS App
  • iOS mWeb Safari
  • iOS mWeb Chrome
  • Windows Chrome
  • MacOS Chrome / Safari
  • MacOS Desktop

This is valuable information because it narrows down the scope of the problem and allows developers to focus their efforts on the affected platform. Knowing which platforms are not affected also helps prioritize the fix – addressing the issue on Android apps is the most pressing concern in this case. Now that we know the workaround situation (or lack thereof) and the platform impact, let's take a look at some visual evidence of the bug in action.

Visual Evidence: Screenshots/Videos

In the world of bug reporting, visual evidence is gold. A picture is worth a thousand words, and a video? Even more so. When you're trying to explain a tricky bug, sometimes words just aren't enough. That's where screenshots and videos come in. They provide concrete proof of the issue, showing exactly what's happening on the screen. In this case, we have a video linked in the bug report: https://github.com/user-attachments/assets/483834ef-6276-4b16-82d7-075563862048

This video likely shows the Expensify app getting stuck on the splash screen after relaunching, following the steps to reproduce outlined earlier. It allows developers and other stakeholders to see the bug firsthand, rather than just reading about it. This is incredibly helpful for a few reasons:

  1. Clarity: It eliminates any ambiguity about what the bug looks like. Everyone can see the same thing, ensuring a shared understanding of the problem.
  2. Diagnosis: Visual evidence can provide clues about the root cause of the bug. For example, the video might show specific elements loading (or not loading) on the splash screen, which could point to a particular module or component that's causing the issue.
  3. Prioritization: Seeing the bug in action can help stakeholders understand its severity and prioritize the fix accordingly. A splash screen freeze is a pretty disruptive bug, and a video demonstrating this can drive home the point.

Unfortunately, I can't directly view the video linked, but its presence in the bug report underscores the importance of visual evidence in the bug reporting process. If you're reporting a bug, always try to include screenshots or videos if possible – they can make a huge difference in getting the issue understood and resolved quickly. Now, let's wrap things up by looking at the call to action and what this means for the Expensify app and its users.

Conclusion and Call to Action

So, we've dissected this Android app splash screen issue pretty thoroughly. We've seen how the app gets stuck after relaunching when trying to sign in via a public room link. We've walked through the steps to reproduce it, highlighted the difference between expected and actual results, and acknowledged the lack of a workaround. We've even emphasized the importance of visual evidence in bug reporting. But what's the takeaway here? And what's the next step?

The main takeaway is that this is a significant bug that needs to be addressed. A splash screen freeze is a major usability issue that can prevent users from accessing the app. The fact that there's no workaround makes it even more critical. Users encountering this bug are essentially locked out of the app until a fix is deployed.

This brings us to the call to action. The bug report includes a link to open jobs on GitHub related to the Expensify app: https://github.com/Expensify/App/issues?q=is%3Aopen+is%3Aissue+label%3A%22Help+Wanted%22

This is a clear call for developers to get involved and help fix this and other issues. If you're an Android developer, or know someone who is, this is an opportunity to contribute to a real-world app and make a positive impact on its users. By tackling this splash screen bug, you'll be directly improving the user experience and ensuring that people can seamlessly access the Expensify app. The more eyes and minds on this problem, the faster a solution can be found and implemented. So, if you're up for the challenge, check out the open jobs and see how you can help! Let's get this splash screen bug squashed and ensure a smooth experience for all Expensify users.