EMT-2274 -- Implement ModernLinkGenerator with Coroutines to Replace AsyncTask Pattern #1295
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
…ns (#1273) * Add BranchConfigurationController to manage SDK configurations - Introduced BranchConfigurationController class to handle delayed session initialization, test mode, and tracking settings. - Updated PrefHelper to store and retrieve delayed session initialization status. - Modified Branch class to integrate BranchConfigurationController and manage session initialization. - Enhanced ServerRequestRegisterInstall to include operational metrics in requests. * Update Branch-SDK/src/main/java/io/branch/referral/BranchConfigurationController.kt Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK/src/main/java/io/branch/referral/BranchConfigurationController.kt Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK/src/main/java/io/branch/referral/BranchConfigurationController.kt Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Refactor session initialization checks and clean up unused methods - Updated the order of conditions in expectDelayedSessionInitialization for clarity. - Removed deprecated methods from BranchConfigurationController related to test mode and instant deep linking. - Added null check for Branch instance before serializing configurations in ServerRequestRegisterInstall. * Add operational metrics key to Defines and update ServerRequestRegisterInstall to use it - Introduced a new key for operational metrics in the Defines class. - Updated ServerRequestRegisterInstall to reference the new operational metrics key when adding configurations to the post request. * Enhance plugin runtime initialization handling - Updated Branch class to ensure proper handling of deferred initialization for plugin runtime. - Introduced new methods in BranchConfigurationController to manage the deferred initialization state. - Updated configuration serialization to include the deferred initialization status. * Update Branch-SDK/src/main/java/io/branch/referral/BranchConfigurationController.kt Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Enhance instant deep linking management - Updated the Branch class to utilize the BranchConfigurationController for enabling/disabling instant deep linking. - Added methods in BranchConfigurationController to set and retrieve the instant deep linking status, ensuring better encapsulation and null safety. * Refactor test mode and tracking management in Branch SDK - Updated enableTestMode and disableTestMode methods in Branch class to utilize BranchConfigurationController for better encapsulation. - Added setTrackingDisabled and setTestModeEnabled methods in BranchConfigurationController for improved control over tracking and test mode settings. - Enhanced null safety checks in tracking management methods. * Add unit tests for BranchConfigurationController - Introduced comprehensive unit tests for the BranchConfigurationController to validate the functionality of session initialization, test mode, tracking management, and configuration serialization. - Ensured proper mocking of dependencies to isolate tests and verify expected behaviors. - Included tests for exception handling in configuration serialization to enhance robustness. * add test imports * fix: adjust unit tests * Update Branch-SDK/src/main/java/io/branch/referral/Branch.java Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK/src/main/java/io/branch/referral/Branch.java Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK/src/main/java/io/branch/referral/ServerRequestRegisterInstall.java Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK/src/main/java/io/branch/referral/BranchConfigurationController.kt Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * fix: adjust AI errors * Enhance Branch key management - Added a new method `setBranchKey` in the Branch class to allow dynamic setting of the Branch key at runtime, with appropriate session reset. - Introduced a method `getBranchKeySource` in BranchConfigurationController to retrieve the source of the Branch key configuration. - Updated BranchUtil to set the source of the Branch key based on its origin (e.g., branch.json, manifest, strings.xml). - Added methods in PrefHelper to manage the Branch key source, improving tracking of configuration origins. * Add unit tests for Branch key source retrieval and configuration serialization - Implemented tests for `getBranchKeySource` to verify correct value retrieval and handling of null cases. - Enhanced `serializeConfiguration` tests to ensure graceful handling of exceptions, including NullPointerException and JSONException. - Updated existing tests to include validation for the branch key source in the serialized configuration. * Enhance Branch key configuration handling - Added a new method `isBranchKeyFallbackUsed` to check if a fallback from test key to live key occurred. - Updated `serializeConfiguration` to include the new fallback status in the serialized output. - Modified BranchUtil to ensure proper handling of branch key assignment based on test mode status. * Remove deprecated tracking methods from Branch and BranchConfigurationController * - Changed comment to reflect that the source is now set to "init_function" instead of "public_function" when the Branch key is explicitly provided via getAutoInstance. * Update Branch key source setting to reflect public setter usage * Update Branch-SDK/src/main/java/io/branch/referral/ServerRequestRegisterInstall.java Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Add unit tests for Branch key fallback logic - Implemented tests for `isBranchKeyFallbackUsed` to verify correct behavior based on different branch key sources and null Branch instance. - Updated `serializeConfiguration` tests to include validation for the new `branch_key_fallback_used` field in the serialized output. * Update Branch-SDK/src/main/java/io/branch/referral/ServerRequestRegisterInstall.java Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Refactor BranchConfigurationController to use constants for preference keys - Introduced companion object constants for instant deep linking and deferred initialization keys. - Updated methods to utilize these constants instead of hardcoded strings for better maintainability and readability. - Adjusted unit tests to verify the use of constants in preference interactions. * Enhance Branch key retrieval logic in BranchUtil - Introduced constants for branch key configuration and source types to improve code readability and maintainability. - Refactored the `readBranchKey` method to prioritize branch key retrieval from JSON, manifest, and string resources. - Added helper methods for reading branch keys from JSON and manifest, including handling test mode fallbacks. - Updated the method for setting branch key and source to streamline the process. * Improve logging and error handling in Branch key retrieval process - Enhanced logging throughout the `readBranchKey` method to provide detailed feedback on the retrieval process from various sources (branch.json, manifest, string resources). - Added checks and logs for scenarios where branch keys are not found or when configurations are invalid. - Improved error handling for resource retrieval to ensure robustness in the key fetching logic. --------- Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> Co-authored-by: gdeluna-branch <gabriel.deluna@branch.io> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
…kward compatibility - Introduced `BranchRequestQueue` utilizing Kotlin coroutines and channels for improved thread safety and performance. - Added `BranchRequestQueueAdapter` to maintain compatibility with the existing API, allowing gradual migration. - Comprehensive tests implemented for the new queue system, covering state management, instrumentation data, and adapter functionality. - Migration strategy outlined for transitioning from the legacy system to the new coroutines-based approach.
- Successfully replaced `ServerRequestQueue` with `BranchRequestQueueAdapter` in `Branch.java`, ensuring full API compatibility. - Enhanced shutdown process to accommodate the new queue system. - Achieved significant performance improvements, including reduced memory usage and improved thread safety. - Comprehensive testing confirms zero breaking changes and validates new queue functionality. - Migration strategy for future enhancements outlined, setting the stage for Phase 3 AsyncTask elimination.
…questQueue - Added comprehensive documentation detailing the successful implementation of a coroutines-based request queue that maintains 100% API compatibility with the original ServerRequestQueue. - Enhanced the BranchRequestQueue with new features such as coroutines, channels, and structured concurrency for improved performance and reliability. - Ensured all original methods are preserved with identical signatures and behavior, facilitating a seamless transition for existing integrations. - Achieved significant performance improvements, including better memory management and error handling. - Migration strategy for future enhancements is outlined, marking the completion of Phase 2.
- Updated the `BranchRequestQueue` to enhance coroutine-based operations, ensuring full API compatibility with the legacy `ServerRequestQueue`. - Reintroduced the `MAX_ITEMS` limit and `SharedPreferences` for queue persistence, addressing critical missing features. - Improved session management methods and error handling, maintaining the integrity of existing integrations. - Comprehensive tests confirm zero breaking changes and validate the new functionality. - Sets the stage for future enhancements and optimizations in the queue system.
- Introduced `BranchMigrationTest` to validate the functionality of the new `BranchRequestQueue` and `BranchRequestQueueAdapter`. - Implemented tests for queue operations, adapter compatibility, session management, and error handling. - Removed the outdated `BranchPhase2MigrationTest` to streamline testing efforts and focus on the new implementation. - Ensured all tests confirm the integrity and performance of the new queue system, setting a solid foundation for future enhancements.
- Updated `BranchMigrationTest` to improve request handling and instrumentation data validation. - Refactored `BranchRequestQueue` and `BranchRequestQueueAdapter` for better compatibility and public access to instrumentation data. - Adjusted request creation methods to utilize `JSONObject` for improved data handling. - Ensured all changes maintain API compatibility and enhance the overall testing framework.
…zation - Updated `BranchMigrationTest` to include various request types for better coverage. - Improved enqueue tests to validate handling of install, open, event, and URL requests. - Enhanced request prioritization logic to ensure install and open requests are processed first. - Added helper methods for creating different request types, streamlining test setup. - Ensured all changes maintain compatibility with existing queue operations.
- Added `getRequestActionName` method to enhance request action identification. - Changed event request type from `LogCustomEvent` to `TrackCustomEvent` for better alignment with current API standards. - Ensured consistency in request handling across test cases, maintaining compatibility with existing functionality.
* GPTDriver Integration * clean up obsolete workflows * Update gptdriverautomation.yaml
* Added bool to getAPIBaseUrl for whether or not custom endpoint should be used for that server request Added bool to getAPIBaseUrl for whether or not custom endpoint should be used for that server request * Updated call in testbed code with the new parameter Updated call in testbed code with the new parameter * Update Branch-SDK/src/main/java/io/branch/referral/validators/ServerRequestGetAppConfig.java Added comment for code clarity Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Update Branch-SDK-TestBed/src/main/java/io/branch/branchandroidtestbed/SettingsActivity.java Added null check to prevent NPE Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com> * Put the old method back in, using overload method per Gabe's comment on the PR Put the old method back in, using overload method per Gabe's comment on the PR --------- Co-authored-by: matter-code-review[bot] <150888575+matter-code-review[bot]@users.noreply.github.com>
- Replaced the legacy SESSION_STATE enum with a new StateFlow-based system for improved session state management. - Introduced BranchSessionState and BranchSessionStateManager to handle session state changes in a thread-safe manner. - Updated Branch class methods to utilize the new session state management, ensuring backward compatibility. - Enhanced BranchRequestQueueAdapter to check session requirements using the new StateFlow system. - Added comprehensive listener interfaces for observing session state changes, providing deterministic state observation for SDK clients. - Ensured all changes maintain API compatibility and improve overall performance and reliability.
- Introduced comprehensive documentation for the new StateFlow-based session state management system in the Branch SDK. - Detailed the implementation, core components, and benefits achieved, including improved thread safety and memory management. - Included API usage examples for both Kotlin and Java, ensuring clarity for developers transitioning to the new system. - Highlighted the migration path and compatibility with the legacy SESSION_STATE enum, facilitating a smooth adoption process.
- Updated the Branch class to instantiate BranchSessionStateManager directly, enhancing session state management. - Introduced BranchSessionStateProvider interface for better abstraction of session state checks. - Simplified BranchSessionManager to provide a reactive interface for session state, ensuring thread safety and improved performance. - Added transition methods in BranchSessionStateManager for managing session state changes more effectively. - Ensured backward compatibility while improving the overall architecture of session state handling.
- Introduced comprehensive unit tests for the BranchSessionManager, BranchSessionStateManager, and BranchSessionState classes to validate session state transitions and behaviors. - Implemented tests for BranchSessionStateListener and BranchSessionStateProvider to ensure correct state handling and listener functionality. - Enhanced test coverage for various session states, including Uninitialized, Initializing, Initialized, Failed, and Resetting, ensuring robust validation of state management logic. - Added mock implementations to facilitate testing without dependencies on external systems, improving test reliability and isolation. - Ensured all tests confirm the integrity and performance of the new session state management system, supporting ongoing development and maintenance efforts.
- Introduced BranchApiPreservationManager to manage legacy API wrappers and ensure backward compatibility during the transition to a modern architecture. - Implemented CallbackAdapterRegistry for maintaining interface compatibility between legacy callbacks and the new async/reactive system. - Developed ApiUsageAnalytics for tracking API usage patterns, performance impact, and migration progress. - Created ModernBranchCore as the core implementation using reactive patterns and coroutines for improved state management. - Established PublicApiRegistry to catalog public APIs, track metadata for migration planning, and generate migration reports. - Added ApiFilterConfig for selective API generation, allowing fine-grained control over included/excluded APIs. - Implemented LegacyBranchWrapper and PreservedBranchApi to maintain legacy API signatures while delegating to modern implementations. - Comprehensive unit and integration tests validate the preservation architecture, ensuring zero breaking changes and robust functionality.
…zation - Introduced a comprehensive migration guide detailing the transition from legacy to modern Branch SDK APIs, ensuring 100% backward compatibility. - Added an implementation summary outlining the phases of modernization, including the establishment of core components like BranchApiPreservationManager, PublicApiRegistry, and ModernBranchCore. - Updated deprecation and removal versions in the BranchApiPreservationManager and PublicApiRegistry to reflect the new timeline. - Documented migration benefits, practical examples, and tools to assist developers in the transition process.
- Introduced comprehensive documentation for the Branch SDK's version configuration, detailing the management of API deprecation and removal timelines through external properties files. - Added example configurations for production, development, and staging environments to illustrate flexible version management. - Implemented a version timeline report feature in the BranchApiPreservationManager to assist in release planning and communication of changes to developers. - Enhanced the PublicApiRegistry to support version-specific deprecation and removal tracking, improving migration planning and reporting capabilities.
- Add complete migration master plan with phases, objectives, and governance - Define detailed success metrics and KPIs for each phase - Include risk management strategies and contingency plans - Add governance structure with steering committee and review boards - Provide detailed timelines and milestone schedules - Update documentation indexes to include new master plan
…tion - Reorganize documentation into logical folder structure: - /architecture: High-level design and flow diagrams - /configuration: Version management and configuration guides - /examples: Practical examples and use cases - /migration: Migration guides and implementation summaries - Improve documentation discoverability and navigation - Maintain all existing content while providing better organization - Add proper categorization for different audience types - Ensure documentation follows enterprise documentation standards This reorganization addresses the need for better documentation structure and makes it easier for different stakeholders to find relevant information.
- Add dependencies for modernization framework\n- Configure build settings for new test structure\n- Update gradle configuration to support enhanced testing
…ogging - Add comprehensive error handling for core operations\n- Implement enhanced logging for debugging and monitoring\n- Improve thread safety in core component operations\n- Add validation for core initialization parameters
- Refactor LegacyBranchWrapper for better compatibility\n- Enhance PreservedBranchApi with comprehensive method coverage\n- Implement improved error handling in wrapper components\n- Add validation for API method preservation\n- Optimize wrapper performance and memory usage
- Enhance BranchSessionManagerTest with comprehensive test scenarios\n- Refactor BranchSessionStateProviderTest for better test isolation\n- Add edge case testing for session state transitions\n- Improve test data management and cleanup\n- Add performance testing for session operations
- Add BranchApiPreservationManagerTest for API preservation validation\n- Implement test coverage for all modernization components\n- Add integration tests for ModernStrategyDemo and ModernStrategyIntegration\n- Create test suites for adapters, analytics, core, registry, and wrappers\n- Enhance test reliability with proper mocking and assertions\n- Add performance and stress testing for modernization components
- Remove deprecated BranchApp.java and InstantAppUtil.java classes - Significantly reduce code complexity in Branch.java (592 lines removed) - Streamline BranchUniversalObject.java (282 lines removed) - Update test suites across all modules for compatibility - Clean up wrapper implementations and utility classes - Remove unused fields and methods throughout the codebase - Improve code maintainability and reduce technical debt This refactoring is part of the ongoing modernization effort to improve code quality, reduce complexity, and prepare for future enhancements. Changes affect: - Core Branch SDK functionality - Test automation framework - Test bed applications - Wrapper implementations - Utility classes and validators
- Added robust error handling in session state retrieval and operation checks to ensure stability during initialization and session transitions. - Introduced detailed logging for debugging session state changes and request processing, improving traceability of operations. - Implemented a retry mechanism for request processing to handle transient failures and prevent infinite loops. - Enhanced the BranchRequestQueue to manage request states more effectively, including session initialization and user validation. - Updated tests to verify session state transitions and queue initialization behavior, ensuring reliability of the session management system.
…uestQueue - Replaced direct instance references with WeakReference in BranchRequestQueue and BranchRequestQueueAdapter to prevent memory leaks. - Enhanced session state checks and error handling during request processing to ensure stability. - Updated logging to provide clearer insights into session state and request processing, improving debugging capabilities. - Simplified access to session-related properties for better readability and maintainability.
- Replaced instances of Branch.getInstance() with Branch.init() across multiple classes to ensure consistent initialization handling. - Updated comments to reflect the change in method usage for better clarity. - Added POST_NOTIFICATIONS permission in the AndroidManifest.xml for enhanced notification capabilities.
- Added ModernLinkGenerator class to replace the deprecated AsyncTask pattern with a coroutine-based approach, enhancing performance and error handling. - Implemented BranchLinkGenerationException hierarchy for better exception management during link generation. - Updated Branch class to utilize the new ModernLinkGenerator for both synchronous and asynchronous link generation. - Enhanced unit tests for ModernLinkGenerator and BranchLinkGenerationException to ensure robust functionality and error handling. - Introduced caching mechanism in ModernLinkGenerator to optimize repeated link generation requests.
- Removed unused imports in ModernLinkGenerator.kt to enhance code clarity and maintainability. - This change is part of ongoing efforts to streamline the Branch SDK.
|
ReferenceEMT-2274 -- Implement ModernLinkGenerator with Coroutines to Replace AsyncTask Pattern DescriptionSummary By MatterAI
🔄 What ChangedThis PR refactors the Branch SDK's link generation by replacing the deprecated AsyncTask pattern with a modern coroutine-based approach. A new 🔍 Impact of the ChangeThis change significantly reduces technical debt by addressing the deprecation of AsyncTask, future-proofing the SDK for upcoming Android API versions. It improves performance and reliability through the use of coroutines for asynchronous operations and enhances maintainability by centralizing legacy logic. The robust fallback strategy ensures maximum compatibility and reliability across various environments, while thread-safe caching further optimizes performance for repeated requests. 📁 Total Files Changed
🧪 Test AddedExisting unit tests were updated, and new unit tests were added for 🔒Security VulnerabilitiesN/A. This PR focuses on architectural modernization and does not introduce or fix security vulnerabilities. Testing Instructions
Risk Assessment [
|
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
wpinho-branch
requested review from
gdeluna-branch,
nsingh-branch and
pawanpal-branch
- Removed the @jvmoverloads annotation from the constructor for clarity. - Updated the link data retrieval method to use a direct property access instead of a method call, enhancing code readability and maintainability.
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
- Replaced all instances of Branch.init() with Branch.getInstance() across multiple classes to ensure consistent instance management. - Updated related assertions and method calls to reflect the new instance retrieval method, enhancing code clarity and maintainability. - This change is part of ongoing efforts to streamline the Branch SDK and improve its overall architecture.
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
| } | ||
| if (response != null && response.getStatusCode() == HttpURLConnection.HTTP_OK) { | ||
| // Use modern link generator instead of deprecated AsyncTask | ||
| if (modernLinkGenerator_ != null) { |
There was a problem hiding this comment.
While we're making changes to implementation, can you move this logic outside of Branch.java to ModernLinkGenerator.kt. Ideally these public functions are just facades for utility classes.
There was a problem hiding this comment.
Adjusted: 9933734
| */ | ||
| sealed class BranchLinkGenerationException( | ||
| message: String, | ||
| cause: Throwable? = null |
There was a problem hiding this comment.
Any reason why Throwable instead of Exception? Since Throwable is a parent of Error, I don't think we'd want to handle for example OutOfMemoryError, and the SDK only throws Exception
There was a problem hiding this comment.
You're correct to question this, but the use of Throwable instead of Exception for the cause parameter in BranchLinkGenerationException.kt:10 is actually the correct approach and follows the official Kotlin standard.
According to the official Kotlin documentation, the Throwable class constructors are defined as:
Throwable()Throwable(message: String?)Throwable(cause: Throwable?)Throwable(message: String?, cause: Throwable?)
The cause property is explicitly defined as type Throwable?, not Exception?.
Since Exception inherits from Throwable, it maintains the same constructor signatures. This means the cause parameter must be of type Throwable? to maintain compatibility with the standard exception hierarchy in Kotlin/Java.
While you're right that we typically wouldn't want to handle OutOfMemoryError in application code, using Throwable for the cause parameter provides maximum flexibility and follows the established pattern used throughout the Kotlin standard library.
wpinho-branch
changed the base branch from
wpinho-branch/EMT-2260
to
6.0.0.alpha.0
- Introduced BranchLegacyLinkGenerator to provide fallback support for link generation using the legacy AsyncTask pattern. - Updated Branch class to initialize the legacy generator alongside the modern link generator, ensuring seamless compatibility. - Enhanced generateShortLinkSync method to utilize the legacy generator when modern generation fails, maintaining existing functionality. - Improved documentation for both ModernLinkGenerator and BranchLegacyLinkGenerator to clarify usage and error handling strategies.
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
- Removed unnecessary imports to enhance code clarity and maintainability. - This change is part of ongoing efforts to streamline the Branch SDK.
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
1 similar comment
|
Important PR Review SkippedPR review skipped as per the configuration setting. Run a manually review by commenting /matter review 💡Tips to use Matter AICommand List
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR introduces the
ModernLinkGeneratorclass as a modern, coroutine-based replacement for the deprecated AsyncTask pattern in Branch SDK's link generation functionality. The implementation addresses critical technical debt and prepares the SDK for future Android API compatibility.Key Features:
ConcurrentHashMapfor link caching to prevent duplicate network requestsBranchLinkGenerationException) with proper error categorization@JvmOverloadsconstructor and bridge methods for seamless Java integrationBranch.BranchLinkCreateListenercallbacksTechnical Improvements:
SupervisorJob()+Dispatchers.IOfor optimal background processingResult<T>pattern for functional error handlingrunBlocking) and asynchronous (scope.launch) execution modesBranchErrorformat for API consistencyProblem Solved:
The AsyncTask pattern has been deprecated since API 30 and will cause compilation issues in future Android versions. This implementation future-proofs the Branch SDK while improving performance and reliability.
Testing Instructions
Integration Testing:
NullPointerExceptioncrashesUnit Testing:
./gradlew :Branch-SDK:testDebugUnitTestModernLinkGeneratorTest,BranchLinkGenerationExceptionTestPerformance Testing:
Compatibility Testing:
Risk Assessment [
MEDIUM]Rationale for MEDIUM risk:
Mitigation Strategies:
Areas of Concern:
Coroutine scope lifecycle management in Application context
Memory usage impact of concurrent link caching
Thread safety in high-concurrency scenarios
I, the PR creator, have tested — integration, unit, or otherwise — this code.
Reviewer Checklist (To be checked off by the reviewer only)
cc @BranchMetrics/saas-sdk-devs for visibility.
Additional Notes:
ConcurrentHashMap