feat(useIAP): add reconnect method for manual connection retry (#3174)

When the initial auto-connect fails (e.g., Play Store not ready at mount
time on Android), there was no way to retry the connection through the
hook — connected would permanently stay false. This adds a reconnect()
method that re-runs initConnection, updates the connected state, and
re-registers event listeners if they were cleaned up during a previous
failure.

Related to hyochan/expo-iap#328

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Added a manual "reconnect" action to restore the in-app purchase
connection and re-establish missing listeners, surfacing errors via the
configured error handler.
* Initialization now centralizes configuration and registers listeners
conditionally to avoid duplicate or inappropriate registrations.

* **Tests**
* Added tests covering reconnect success/failure paths and
Android-specific listener and reinitialization behavior.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyochan

src/__tests__/hooks/useIAP.android.test.ts

@@ -125,4 +125,55 @@ describe('hooks/useIAP Android', () => {
       enableBillingProgramAndroid: 'external-offer',
     });
   });
+
+  it('registers userChoiceBillingAndroid listener when callback is provided', async () => {
+    const mockUserChoiceBillingListener = jest
+      .spyOn(IAP, 'userChoiceBillingListenerAndroid' as any)
+      .mockImplementation(() => ({remove: jest.fn()}));
+
+    let api: any;
+    const onUserChoiceBilling = jest.fn();
+    const Harness = () => {
+      api = useIAP({
+        onUserChoiceBillingAndroid: onUserChoiceBilling,
+      });
+      return null;
+    };
+
+    await act(async () => {
+      TestRenderer.create(React.createElement(Harness));
+    });
+    await act(async () => {});
+
+    expect(api.connected).toBe(true);
+    expect(mockUserChoiceBillingListener).toHaveBeenCalled();
+  });
+
+  it('reconnect uses Android billing config', async () => {
+    let api: any;
+    const Harness = () => {
+      api = useIAP({
+        enableBillingProgramAndroid: 'user-choice-billing',
+      });
+      return null;
+    };
+
+    await act(async () => {
+      TestRenderer.create(React.createElement(Harness));
+    });
+    await act(async () => {});
+
+    (IAP.initConnection as jest.Mock).mockClear();
+    jest.spyOn(IAP, 'initConnection').mockResolvedValueOnce(true as any);
+
+    let result: boolean | undefined;
+    await act(async () => {
+      result = await api.reconnect();
+    });
+
+    expect(result).toBe(true);
+    expect(IAP.initConnection).toHaveBeenCalledWith({
+      enableBillingProgramAndroid: 'user-choice-billing',
+    });
+  });
 });

src/__tests__/hooks/useIAP.test.ts

@@ -417,4 +417,133 @@ describe('hooks/useIAP (renderer)', () => {
       expect(initConnectionSpy).toHaveBeenCalled();
     });
   });
+
+  describe('reconnect', () => {
+    it('reconnects and returns true on success', async () => {
+      let api: any;
+      const Harness = () => {
+        api = useIAP();
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+      await act(async () => {});
+
+      // Reset mock to track reconnect call
+      (IAP.initConnection as jest.Mock).mockClear();
+      jest.spyOn(IAP, 'initConnection').mockResolvedValue(true as any);
+
+      let result: boolean | undefined;
+      await act(async () => {
+        result = await api.reconnect();
+      });
+
+      expect(result).toBe(true);
+      expect(api.connected).toBe(true);
+    });
+
+    it('returns false and sets connected=false when initConnection returns false', async () => {
+      let api: any;
+      const Harness = () => {
+        api = useIAP();
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+      await act(async () => {});
+
+      jest.spyOn(IAP, 'initConnection').mockResolvedValueOnce(false as any);
+
+      let result: boolean | undefined;
+      await act(async () => {
+        result = await api.reconnect();
+      });
+
+      expect(result).toBe(false);
+      expect(api.connected).toBe(false);
+    });
+
+    it('calls onError and returns false when reconnect fails', async () => {
+      const reconnectError = new Error('Reconnect failed');
+
+      let api: any;
+      const onError = jest.fn();
+      const Harness = () => {
+        api = useIAP({onError});
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+      await act(async () => {});
+
+      jest.spyOn(IAP, 'initConnection').mockRejectedValueOnce(reconnectError);
+
+      let result: boolean | undefined;
+      await act(async () => {
+        result = await api.reconnect();
+      });
+
+      expect(result).toBe(false);
+      expect(onError).toHaveBeenCalledWith(reconnectError);
+    });
+
+    it('does not throw when reconnect fails without onError', async () => {
+      let api: any;
+      const Harness = () => {
+        api = useIAP();
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+      await act(async () => {});
+
+      jest
+        .spyOn(IAP, 'initConnection')
+        .mockRejectedValueOnce(new Error('fail'));
+
+      let result: boolean | undefined;
+      await act(async () => {
+        result = await api.reconnect();
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('reconnect re-registers listeners after successful reconnection', async () => {
+      let api: any;
+      const onPurchaseSuccess = jest.fn();
+      const Harness = () => {
+        api = useIAP({onPurchaseSuccess});
+        return null;
+      };
+
+      await act(async () => {
+        TestRenderer.create(React.createElement(Harness));
+      });
+      await act(async () => {});
+
+      // purchaseUpdatedListener should have been called during init
+      expect(IAP.purchaseUpdatedListener).toHaveBeenCalled();
+
+      // Clear and reconnect
+      (IAP.purchaseUpdatedListener as jest.Mock).mockClear();
+      jest.spyOn(IAP, 'initConnection').mockResolvedValueOnce(true as any);
+
+      await act(async () => {
+        await api.reconnect();
+      });
+
+      // Listeners are already active from init, so reconnect skips re-registration
+      // (guarded by !subscriptionsRef.current.purchaseUpdate check)
+      expect(api.connected).toBe(true);
+    });
+  });
 });