Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[$250] Android - Chat - Unable to close keyboard by tapping outside of it #53196

Open
2 of 8 tasks
IuliiaHerets opened this issue Nov 27, 2024 · 44 comments
Open
2 of 8 tasks
Assignees
Labels
Bug Something is broken. Auto assigns a BugZero manager. External Added to denote the issue can be worked on by a contributor Monthly KSv2 Reviewing Has a PR in review

Comments

@IuliiaHerets
Copy link

IuliiaHerets commented Nov 27, 2024

If you haven’t already, check out our contributing guidelines for onboarding and email [email protected] to request to join our Slack channel!


Version Number: 9.0.67-1
Reproducible in staging?: Y
Reproducible in production?: Y
If this was caught on HybridApp, is this reproducible on New Expensify Standalone?: Y
Email or phone of affected tester (no customers): [email protected]
Issue reported by: Applause Internal Team

Action Performed:

  1. Open the Expensify app.
  2. Open any chat that has messages on it.
  3. Tap on compose box to open keyboard.
  4. Tap outside the keyboard area to close it.
  5. Verify that the keyboard is closed when tapping outside of it.

Expected Result:

Keyboard should be closed when tapping outside of it.

Actual Result:

Keyboard is not closed when tapping outside of it in chats that already have messages. Keyboard closes normally when the chat doesn´t have any message or content on it.

Workaround:

Unknown

Platforms:

  • Android: Standalone
  • Android: HybridApp
  • Android: mWeb Chrome
  • iOS: Standalone
  • iOS: HybridApp
  • iOS: mWeb Safari
  • MacOS: Chrome / Safari
  • MacOS: Desktop

Screenshots/Videos

Bug6677688_1732684892160.Tap_Keyboard.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit
  • Upwork Job URL: https://www.upwork.com/jobs/~021861915865037036576
  • Upwork Job ID: 1861915865037036576
  • Last Price Increase: 2024-11-27
  • Automatic offers:
    • daledah | Contributor | 105283329
Issue OwnerCurrent Issue Owner: @alitoshmatov
@IuliiaHerets IuliiaHerets added Daily KSv2 Bug Something is broken. Auto assigns a BugZero manager. labels Nov 27, 2024
Copy link

melvin-bot bot commented Nov 27, 2024

Triggered auto assignment to @mallenexpensify (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

@gadhiyamanan
Copy link
Contributor

Proposal

Please re-state the problem that we are trying to solve in this issue.

keyboard does not close on Tap outside the keyboard

What is the root cause of that problem?

we are using keyboardShouldPersistTaps="handled" props in ReportActionsList.tsx because of that keyboard will not dismiss automatically on Tap outside the keyboard

<InvertedFlatList
accessibilityLabel={translate('sidebarScreen.listOfChatMessages')}
ref={reportScrollManager.ref}
testID="report-actions-list"
style={styles.overscrollBehaviorContain}
data={sortedVisibleReportActions}
renderItem={renderItem}
contentContainerStyle={contentContainerStyle}
keyExtractor={keyExtractor}
initialNumToRender={initialNumToRender}
onEndReached={onEndReached}
onEndReachedThreshold={0.75}
onStartReached={onStartReached}
onStartReachedThreshold={0.75}
ListFooterComponent={listFooterComponent}
ListHeaderComponent={listHeaderComponent}
keyboardShouldPersistTaps="handled"
onLayout={onLayoutInner}
onContentSizeChange={onContentSizeChangeInner}
onScroll={trackVerticalScrolling}
onScrollToIndexFailed={onScrollToIndexFailed}
extraData={extraData}
key={listID}
shouldEnableAutoScrollToTopThreshold={shouldEnableAutoScrollToTopThreshold}
/>

What changes do you think we should make in order to solve the problem?

we can use keyboardShouldPersistTaps="never" in ReportActionsList.tsx or remove keyboardShouldPersistTaps prop because by default the value of keyboardShouldPersistTaps is never

@mallenexpensify mallenexpensify added the External Added to denote the issue can be worked on by a contributor label Nov 27, 2024
@melvin-bot melvin-bot bot changed the title Android - Chat - Unable to close keyboard by tapping outside of it [$250] Android - Chat - Unable to close keyboard by tapping outside of it Nov 27, 2024
Copy link

melvin-bot bot commented Nov 27, 2024

Job added to Upwork: https://www.upwork.com/jobs/~021861915865037036576

@melvin-bot melvin-bot bot added the Help Wanted Apply this label when an issue is open to proposals by contributors label Nov 27, 2024
Copy link

melvin-bot bot commented Nov 27, 2024

Triggered auto assignment to Contributor-plus team member for initial proposal review - @alitoshmatov (External)

@mallenexpensify
Copy link
Contributor

👋 @gadhiyamanan , it's been a minute!
@alitoshmatov , plz attempt reproduction. If you're able to repro, please review Manan's proposal. I won't be able to test on Android til I'm back in the bank on Monday.

@huult
Copy link
Contributor

huult commented Nov 28, 2024

Edited by proposal-police: This proposal was edited at 2024-11-28 04:11:57 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

Unable to close keyboard by tapping outside of it

What is the root cause of that problem?

We are using keyboardShouldPersistTaps with the value handled, but with this setup, we are unable to hide the keyboard when tapping outside

keyboardShouldPersistTaps="handled"

'handled', the keyboard will not dismiss automatically when the tap was handled by a children, (or captured by an ancestor).
false, deprecated, use 'never' instead
true, deprecated, use 'always' instead

Screenshot 2024-11-28 at 11 21 42

What changes do you think we should make in order to solve the problem?

To resolve this issue and avoid impacting the current logic and behavior, we should handle the onPress event of ReportActionItem to dismiss the keyboard. Something like this:

// src/pages/home/report/ReportActionsListItemRenderer.tsx#L162
    <ReportActionItem
        shouldHideThreadDividerLine={shouldHideThreadDividerLine}
        parentReportAction={parentReportAction}
        report={report}
        transactionThreadReport={transactionThreadReport}
        parentReportActionForTransactionThread={parentReportActionForTransactionThread}
        action={action}
        reportActions={reportActions}
        linkedReportActionID={linkedReportActionID}
        displayAsGroup={displayAsGroup}
        shouldDisplayNewMarker={shouldDisplayNewMarker}
        shouldShowSubscriptAvatar={
            (ReportUtils.isPolicyExpenseChat(report) || ReportUtils.isInvoiceRoom(report)) &&
            [
                CONST.REPORT.ACTIONS.TYPE.IOU,
                CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
                CONST.REPORT.ACTIONS.TYPE.SUBMITTED,
                CONST.REPORT.ACTIONS.TYPE.APPROVED,
                CONST.REPORT.ACTIONS.TYPE.FORWARDED,
            ].some((type) => type === reportAction.actionName)
        }
        isMostRecentIOUReportAction={reportAction.reportActionID === mostRecentIOUReportActionID}
        index={index}
        isFirstVisibleReportAction={isFirstVisibleReportAction}
        shouldUseThreadDividerLine={shouldUseThreadDividerLine}
+        onPress={() => {
+            Keyboard.dismiss();
+        }}
    />
POC
Screen.Recording.2024-11-28.at.11.07.51.mov

Note: For similar cases like this issue, we can reuse this solution

What alternative solutions did you explore? (Optional)

@daledah
Copy link
Contributor

daledah commented Nov 29, 2024

Edited by proposal-police: This proposal was edited at 2024-11-29 07:35:59 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

Keyboard is not closed when tapping outside of it in chats that already have messages. Keyboard closes normally when the chat doesn´t have any message or content on it.

What is the root cause of that problem?

  • We are using:

keyboardShouldPersistTaps="handled"

'handled': the keyboard will not dismiss automatically when the tap was handled by children of the scroll view (or captured by an ancestor).

That means the keyboard will not be dismissed if the tap is handled by the children.

  • The state mentioned in OP "Keyboard is not closed when tapping outside of it in chats that already have messages" is not fully correct. Given the below image:

image

The keyboard is still closed if we click on red area. When clicking on the white area, the keyboard is not closed. It is because the red area is just a normal View component:

<View style={[styles.pRelative]}>

so it cannot handle the tap. So the keyboard is closed.

Otherwise, with the white area, it is the Pressable component:

<PressableWithSecondaryInteraction

so it can handle the tap. Based on the docs, the keyboard will not dismiss automatically when the tap was handled by children.

What changes do you think we should make in order to solve the problem?

  • We can use onStartShouldSetResponder in here:

<View style={highlightedBackgroundColorIfNeeded}>

                    <View
                        onStartShouldSetResponder={() => {
                            Keyboard.dismiss();
                            return false;
                        }}
                        style={highlightedBackgroundColorIfNeeded}
                    >

or

                    <View
                        onStartShouldSetResponder={() => {
                            setTimeout(() => {
                                Keyboard.dismiss();
                            }, 500); // 500ms to recognize the long press
                            return false;
                        }}
                        style={highlightedBackgroundColorIfNeeded}
                    >
  • Explanation: Based on the docs:

onStartShouldSetResponder are called with a bubbling pattern, where the deepest node is called first. That means that the deepest component will become responder when multiple Views return true for *ShouldSetResponder handlers. This is desirable in most cases, because it makes sure all controls and buttons are usable.

This means that if the deepest component in:

<PressableWithSecondaryInteraction

is an interactive component (such as Button, Pressable, etc.), the onStartShouldSetResponder will not be called. However, if the deepest component is a non-interactive component (like View, Text, etc.), the onStartShouldSetResponder will be triggered, in other words, we call Keyboard.dismiss() in this case.

What alternative solutions did you explore? (Optional)

  • We need to manually close the keyboard when user clicks on white area. To do it, we can update:

onPress={draftMessage === undefined ? onPress : undefined}

            onPress={
                draftMessage === undefined
                    ? () => {
                          onPress?.();
                          Keyboard.dismiss();
                      }
                    : undefined
            }

or

            onPress={
                draftMessage === undefined
                    ? () => {
                          onPress?.();
                          Keyboard.dismiss();
                      }
                    : () => {
                          Keyboard.dismiss();
                      }
            }
  • Before calling Keyboard.dismiss(), we can check whether the keyboard is opening or not. If so, call Keyboard.dismiss().

@ikevin127
Copy link
Contributor

ikevin127 commented Dec 1, 2024

Edited by proposal-police: This proposal was edited at 2024-12-02 12:26:18 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue

In chat reports that have messages, the keyboard is not closed when tapping outside of it on any of the messages.

What is the root cause of that problem?

The keyboardShouldPersistTaps="handled" prop is passed to the InvertedFlatList here (has been there for more than 18 months at this point), handled meaning:

handled: the keyboard will not dismiss automatically when the tap was handled by a children, (or captured by an ancestor).

in our case, the chat report message being a PressableWithSecondaryInteraction which already handles tap (onPress), the keyboard won't close when tapped on a message (onPress).

What changes do you think we should make in order to solve the problem?

Given that keyboardShouldPersistTaps="handled" has been there for over 18 months, I don't think we should remove or change it because that would also remove the onLongPress behaviour of the message which opens the context menu (even with the keyboard open) and we would have to close the keyboard first then long press on a message in order to open the context menu (which is bad UX).

The ideal solution here would have to fulfil both:

  • keep the current onLongPress message functionality (even with the keyboard open)
  • dismiss the keyboard when simple tap (onPress) is performed on a message while the keyboard is opened

Therefore I'm coming forward with the following solution which allows to dynamically set the required behaviour based on a prop that stands at the root of our BaseGenericPressable component and can be easily passed only where we need it, in our ReportActionItem component to PressableWithSecondaryInteraction.

Implementation

  1. In our BaseGenericPressable.tsx component add a new prop shouldDismissKeyboardOnPress (boolean) defaulting to false (make sure to add the type PressableProps).
  2. In the same component, within the the onPressHandler function, before return onPress(event); add:
if (shouldDismissKeyboardOnPress && Keyboard.isVisible()) {
    Keyboard.dismiss();
}

leveraging our newly added prop and react-native's Keyboard to ensure we only dismiss the keyboard when required by the new prop and when the keyboard is actually visible.

  1. In ReportActionItem.tsx pass the newly added shouldDismissKeyboardOnPress prop to PressableWithSecondaryInteraction as true (no need to add ={true}).

And we're done, this ensures we can dynamically add the dismiss functionality for the onPress using the shouldDismissKeyboardOnPress to elegantly get around the list's keyboardShouldPersistTaps="handled" prop and fulfil the issue's Expected result while providing a way for developers to use the same prop should similar issues arise in the future.

Here's a diff of all the changes for convenience:

DIFF
diff --git a/src/components/Pressable/GenericPressable/implementation/BaseGenericPressable.tsx b/src/components/Pressable/GenericPressable/implementation/BaseGenericPressable.tsx
index 1765560eaae..9bdeb82fc6a 100644
--- a/src/components/Pressable/GenericPressable/implementation/BaseGenericPressable.tsx
+++ b/src/components/Pressable/GenericPressable/implementation/BaseGenericPressable.tsx
@@ -2,7 +2,7 @@ import type {ForwardedRef} from 'react';
 import React, {forwardRef, useCallback, useEffect, useMemo, useState} from 'react';
 import type {GestureResponderEvent, View} from 'react-native';
 // eslint-disable-next-line no-restricted-imports
-import {Pressable} from 'react-native';
+import {Keyboard, Pressable} from 'react-native';
 import type {PressableRef} from '@components/Pressable/GenericPressable/types';
 import type PressableProps from '@components/Pressable/GenericPressable/types';
 import useSingleExecution from '@hooks/useSingleExecution';
@@ -37,6 +37,7 @@ function GenericPressable(
         accessible = true,
         fullDisabled = false,
         interactive = true,
+        shouldDismissKeyboardOnPress = false,
         ...rest
     }: PressableProps,
     ref: PressableRef,
@@ -115,6 +116,9 @@ function GenericPressable(
                 ref.current?.blur();
                 Accessibility.moveAccessibilityFocus(nextFocusRef);
             }
+            if (shouldDismissKeyboardOnPress && Keyboard.isVisible()) {
+                Keyboard.dismiss();
+            }
             return onPress(event);
         },
         [shouldUseHapticsOnPress, onPress, nextFocusRef, ref, isDisabled, interactive],
diff --git a/src/components/Pressable/GenericPressable/types.ts b/src/components/Pressable/GenericPressable/types.ts
index 61cb6db8ee7..d8f38a44fda 100644
--- a/src/components/Pressable/GenericPressable/types.ts
+++ b/src/components/Pressable/GenericPressable/types.ts
@@ -148,6 +148,11 @@ type PressableProps = RNPressableProps &
          * e.g., show disabled cursor when disabled
          */
         interactive?: boolean;
+
+        /** Used for when a list has keyboardShouldPersistTaps set to `handled`
+         * and we need the keyboard to be dismissed on onPress.
+         */
+        shouldDismissKeyboardOnPress?: boolean;
     };
 
 type PressableRef = ForwardedRef<HTMLDivElement | View | RNText | undefined>;
diff --git a/src/pages/home/report/ReportActionItem.tsx b/src/pages/home/report/ReportActionItem.tsx
index 399550069c0..963b2787158 100644
--- a/src/pages/home/report/ReportActionItem.tsx
+++ b/src/pages/home/report/ReportActionItem.tsx
@@ -968,6 +968,7 @@ function ReportActionItem({
             withoutFocusOnSecondaryInteraction
             accessibilityLabel={translate('accessibilityHints.chatMessage')}
             accessible
+            shouldDismissKeyboardOnPress
         >
             <Hoverable
                 shouldHandleScroll

What alternative solutions did you explore?

Alternatively, skip the addition of the shouldDismissKeyboardOnPress prop and simply add the keyboard dismiss logic in the same place as stated in the main solution.

Result video (before / after)

Android: Native (One Plus 7T - Real device)
Before After
before.mp4
after.mp4

@melvin-bot melvin-bot bot added the Overdue label Dec 1, 2024
@daledah
Copy link
Contributor

daledah commented Dec 1, 2024

Proposal updated

@alitoshmatov
Copy link
Contributor

@gadhiyamanan Thank you for your proposal, keyboardShouldPersistTaps="handled" is there for a reason, as other proposals showed removing it will affect onLongPress behavior

@melvin-bot melvin-bot bot removed the Overdue label Dec 2, 2024
@alitoshmatov
Copy link
Contributor

@huult Thank you for your proposal, your solution is solving the issue

@alitoshmatov
Copy link
Contributor

@daledah Thank you for detailed RCA. I think onStartShouldSetResponder is overkill here and we could just use onPress instead

@alitoshmatov
Copy link
Contributor

@ikevin127 Thank you for your proposal, While your solution does solve the issue I don't think we need to introduce a new attribute here as I don't think there is a much use-case for this. Even if we come across similar problem, then we can refactor code to implement similar attribute. For now, I think we can just use onPress

@alitoshmatov
Copy link
Contributor

We can go with @huult 's proposal which proposes simple solution and does not affect long press behavior

C+ reviewed 🎀 👀 🎀

Copy link

melvin-bot bot commented Dec 2, 2024

Triggered auto assignment to @AndrewGable, see https://stackoverflow.com/c/expensify/questions/7972 for more details.

@daledah
Copy link
Contributor

daledah commented Dec 2, 2024

@alitoshmatov

This solution ensures that the app's behavior remains consistent for the TaskPreview component. In the case of the TaskPreview component, clicking on the checkbox does not dismiss the keyboard (Behavior in latest main). However, in my alternative solution below, clicking on the checkbox will dismiss the keyboard (Not the behavior in latest main).

And it does not fully fix the issue as well since we are using the ReportActionItem in a lot of places, not only one place.

  • I don't think onStartShouldSetResponder is overkill here. It is only the one line change and we already the docs for it.

cc @AndrewGable

@alitoshmatov
Copy link
Contributor

The #53196 (comment) can change the original behavior (can be considered as regression) as I explained in my #53196 (comment)

@daledah But chosen proposal is not causing the regression you mentioned

Screen.Recording.2024-12-02.at.5.07.42.PM.mov

@ikevin127
Copy link
Contributor

Thanks for the review!

I don't think we need to introduce a new attribute here as I don't think there is a much use-case for this. Even if we come across similar problem, then we can refactor code to implement similar attribute.

I'm curious to hear @AndrewGable's take on this as well since IMO we should implement new solutions with foresight in mind instead of refactoring later.

Caution

Besides the question posed above, the selected solution only mentioned adding onPress to the ReportActionItem within ReportActionsListItemRenderer without considering ReportActionItemParentAction.

@alitoshmatov You might want to take a second look at this and reconsider my solution for a complete fix which would not require adding onPress multiple times in separate components - for this I added an alternative to my proposal where we don't introduce a new prop 🙂

Updated proposal

  • added alternative to not introduce new prop

@daledah
Copy link
Contributor

daledah commented Dec 2, 2024

But chosen proposal is not causing the regression you mentioned

@alitoshmatov Sorry, I cannot reproduce the bug when applying the selected proposal anymore. Maybe I am adding something when apply that solution leads to the regression is encountered from my side.

And it does not fully fix the issue as well since we are using the ReportActionItem in a lot of places, not only one place.

What do you think about this? Such as in here, if ReportUtils.canCurrentUserOpenReportis false, so the onPress function is undefined, the bug is not fixed.

@alitoshmatov
Copy link
Contributor

@ikevin127 I don't think closing keyboard on every onPress of BaseGenericPressable is a good idea, I assume it is pretty big change across the app, it might introduce new regressions as we can't test all the instance of its usage. I think we should focus on current issue alone

@huult
Copy link
Contributor

huult commented Dec 4, 2024

No, it seems hard to get to reproduce that case.

@alitoshmatov Yes, I will test more cases and note that case. If I am able to reproduce it, I will fix it or add a check in case onPress is undefined. Do you agree?

@alitoshmatov
Copy link
Contributor

Yes that is definitely a valid concern. Whether it is reproducible or not, it is still something to cover in the solution.

@alitoshmatov
Copy link
Contributor

alitoshmatov commented Dec 4, 2024

@daledah I still think we should apply onPress rather than onStartShouldSetResponder here. That is why I think we should go with @huult 's solution.
I just wanted to make sure everyone is happy with this decision, if not we should consult @AndrewGable to make a final decision. @daledah What do you think?

@daledah
Copy link
Contributor

daledah commented Dec 4, 2024

I still think we should apply onPress rather than onStartShouldSetResponder here. That is why I think we should go with @huult 's solution.

@alitoshmatov My alternative solution works well and can make sure we do not miss any case such as this one or when draftMessage !== undefined in here. What do you think?

About the case draftmessage !== undefined, clicking on the area outside the input box (green area in the below image) should close the keyboard:

image

@alitoshmatov
Copy link
Contributor

Note: This solution ensures that the app's behavior remains consistent for the TaskPreview component. In the case of the TaskPreview component, clicking on the checkbox does not dismiss the keyboard (Behavior in latest main). However, in my alternative solution below, clicking on the checkbox will dismiss the keyboard (Not the behavior in latest main).

@daledah But this introduces this regression, right?

@huult
Copy link
Contributor

huult commented Dec 4, 2024

Whatever the outcome, I respect your choice, @alitoshmatov.

The solution for this ticket is to use onPress to trigger the call to dismiss the keyboard.

If we choose this solution, I believe my proposal should be selected because it was submitted first and provides the correct solution.

Regarding “onPress being undefined,” we can check this in the pull request phase because the proposal includes a code example to describe the solution I mentioned.

The contribution guide states that all new proposals must be different from existing proposals.

@daledah
Copy link
Contributor

daledah commented Dec 4, 2024

But this introduces this regression, right?

No. I just tested the alternative solution and there is no regression. I updated the proposal to remove that note.

@huult
Copy link
Contributor

huult commented Dec 4, 2024

@alitoshmatov I just tested the case draftMessage !== undefined, and we are able to dismiss the keyboard when tapping outside.

Screen.Recording.2024-12-05.at.00.40.52.mp4

@daledah
Copy link
Contributor

daledah commented Dec 4, 2024

@huult You can check my mean in comment, I just updated it.

@huult
Copy link
Contributor

huult commented Dec 4, 2024

@daledah Anyway, I think @alitoshmatov had more context to decide which one to go with. Let's wait for the result 🙂

@ikevin127
Copy link
Contributor

I just wanted to make sure everyone is happy with this decision

@alitoshmatov I'm not, I don't understand why any of my proposed solutions are not meeting the requirements even after adding the no new prop as alternative after it was mentioned in #53196 (comment).

I don't think closing keyboard on every onPress of BaseGenericPressable is a good idea, I assume it is pretty big change across the app, it might introduce new regressions as we can't test all the instance of its usage. I think we should focus on current issue alone

Then you backpedaled that decision basically invalidating my alternative solution (excluding the new prop), then I mentioned in #53196 (comment) how and why I proposed the new prop in my main solution - because it allows to control exactly when and where we want the Keyboard.dismiss() functionality and it would adhere to the DRY principle (compared to the other proposals).

So far none of the other proposals offered a solution that targets the root onPress function, instead suggested adding multiple onPress calls in different components which goes against our DRY principle.

I'm still wondering why, given the main / alternative solutions added to my proposal - it's still being ignored in the favor of any of the other proposals. Maybe @AndrewGable can give me a straight answer to that question from a technical point of view, I would appreciate it.

@alitoshmatov
Copy link
Contributor

@ikevin127 Thanks for your feedback, I really appreciate it.

I didn't approve applying changes to BaseGenericPressable altogether, my reasoning is that BaseGenericPressable is too down the road, whether we apply onPress to selected instances or all of them. Adding additional prop and/or logic to dismiss keyboard on every pressable component is rather unnecessary and large change. The issue is happening only in report page(as we know right now) so we should keep it to this scope.

So far none of the other proposals offered a solution that targets the root onPress function, instead suggested adding multiple onPress calls in different components which goes against our DRY principle.

I haven't seen any compelling argument here for why BaseGenericPressable's onPress should be the root or the main focus. As all proposals pointed it out keyboardShouldPersistTaps="handled" is causing this issue but we decided not to change it, so the next logical move is to apply solution to components that are effected by this.

Moreover @huult's proposal suggested adding one onPress, though I did miss this part which might cause adding second onPress but we were still discussing how to resolve this one.
@daledah's proposal, specifically alternative solution, which we are discussing also suggests changing single onPress.

My above points might come of as aggressive as it’s difficult to convey tone through writing, I just want to show you my reasoning and thought process. That said, there is always a chance I might be wrong and I open to reevaluating all the proposals again. If you think so I will be happy to invite another C+ and reassign this issue to them.

@ikevin127
Copy link
Contributor

No need to reassign, I just wanted to understand the reasoning. Thanks!

Copy link

melvin-bot bot commented Dec 10, 2024

@AndrewGable, @mallenexpensify, @alitoshmatov Eep! 4 days overdue now. Issues have feelings too...

@melvin-bot melvin-bot bot added the Overdue label Dec 10, 2024
@alitoshmatov
Copy link
Contributor

Okay, after a lot of consideration I think we should go with @daledah 's alternative solution which suggests to update onPress of ReportActionItem

C+ reviewed 🎀 👀 🎀

cc: @AndrewGable

@melvin-bot melvin-bot bot removed the Overdue label Dec 10, 2024
Copy link

melvin-bot bot commented Dec 10, 2024

Current assignee @AndrewGable is eligible for the choreEngineerContributorManagement assigner, not assigning anyone new.

@melvin-bot melvin-bot bot removed the Help Wanted Apply this label when an issue is open to proposals by contributors label Dec 10, 2024
Copy link

melvin-bot bot commented Dec 10, 2024

📣 @daledah 🎉 An offer has been automatically sent to your Upwork account for the Contributor role 🎉 Thanks for contributing to the Expensify app!

Offer link
Upwork job
Please accept the offer and leave a comment on the Github issue letting us know when we can expect a PR to be ready for review 🧑‍💻
Keep in mind: Code of Conduct | Contributing 📖

Copy link

melvin-bot bot commented Dec 11, 2024

@AndrewGable @mallenexpensify @alitoshmatov @daledah this issue was created 2 weeks ago. Are we close to approving a proposal? If not, what's blocking us from getting this issue assigned? Don't hesitate to create a thread in #expensify-open-source to align faster in real time. Thanks!

@melvin-bot melvin-bot bot added Reviewing Has a PR in review Weekly KSv2 and removed Daily KSv2 labels Dec 12, 2024
@melvin-bot melvin-bot bot added Monthly KSv2 and removed Weekly KSv2 labels Jan 6, 2025
Copy link

melvin-bot bot commented Jan 6, 2025

This issue has not been updated in over 15 days. @AndrewGable, @mallenexpensify, @alitoshmatov, @daledah eroding to Monthly issue.

P.S. Is everyone reading this sure this is really a near-term priority? Be brave: if you disagree, go ahead and close it out. If someone disagrees, they'll reopen it, and if they don't: one less thing to do!

@mallenexpensify
Copy link
Contributor

PR is moving along!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
Bug Something is broken. Auto assigns a BugZero manager. External Added to denote the issue can be worked on by a contributor Monthly KSv2 Reviewing Has a PR in review
Projects
None yet
Development

No branches or pull requests

8 participants