react native: how to debug android in release mode

Debugging React Native apps in release mode for Android can be challenging because release builds are optimized and obfuscated, making it difficult to inspect code and debug in real-time. However, there are several techniques you can use to debug your app effectively: 1. Debugging with Chrome DevTools You can use Chrome DevTools to debug your React Native app running in release mode on an Android device or emulator: 1. Open your app on the device or emulator. 2. Shake the device or press C

Post, Code and Quiet Time. react native: how to debug android in release mode By Errong Leng – 15 May 2024 – View online → Photo by Luke Miller / Unsplash Debugging React Native apps in release mode for Android can be challenging because release builds are optimized and obfuscated, making it difficult to inspect code and debug in real-time. However, there are several techniques you can use to debug your app effectively: 1. Debugging with Chrome DevTools You can use Chrome DevTools to debug your React Native app running in release mode on an Android device or emulator: Open your app on the device or emulator. Shake the device or press Ctrl + M (Cmd + M on macOS) to open the developer menu. Select "Debug JS Remotely." This will open Chrome with DevTools. Open the DevTools console to view logs and errors. You can also use the "Sources" tab to inspect and debug your JavaScript code. 2. Logging and Remote Debugging You can use console.log() statements in your code to log information, warnings, and errors. These logs will appear in the console of your development machine when your device is connected via USB. console.log('Debugging message'); 3. React Native Debugger Use React Native Debugger, which is a standalone app that includes DevTools and additional debugging features: Install React Native Debugger: https://github.com/jhen0409/react-native-debugger Run your app in release mode. Open React Native Debugger and connect to your running app. 4. Sentry or Bugsnag Integrate a crash reporting tool like Sentry or Bugsnag into your app. These tools capture and report errors, crashes, and performance issues in release builds. 5. Android Logcat You can view Android log messages using Logcat: adb logcat *:E This will display error-level logs. You can adjust the filter to display other log levels (*:W for warnings, *:D for debug, etc.). 6. Debug Symbols and Source Maps Make sure you have generated debug symbols and source maps for your release build. This will allow you to symbolicate crash reports and view meaningful stack traces. 7. Debugging with adb reverse If you are debugging on a physical device connected via USB, you can use adb reverse to forward debug server requests to your development machine: adb reverse tcp:8081 tcp:8081 This allows your release build to connect to the Metro Bundler running on your development machine. 8. TestFlight or Google Play Internal Testing Deploy your release build to a testing environment such as TestFlight (iOS) or Google Play Internal Testing (Android) to gather feedback from testers before releasing to production. 9. Manual Testing Perform thorough manual testing on release builds to identify and reproduce issues that may not be caught during development. While debugging in release mode can be more challenging, combining these techniques should help you effectively identify and resolve issues in your React Native app. Post, Code and Quiet Time. © 2024 – Unsubscribe

Fix Crash caused by TransactionTooLargeException in InterstitialAd.show()

The issue since happened a few years back since 2019. as time went by, in 2024, I still faced this issue while testing my android app release version. 535 866 E ActivityTaskManager: Second failure launching com.lengerrong.coca/com.google.android.gms.ads.AdActivity, giving up 05-15 03:12:28.066 535 866 E ActivityTaskManager: android.os.TransactionTooLargeException: data parcel size 537904 bytes 05-15 03:12:28.066 535 866 E ActivityTaskManager: at android.os.BinderProxy.transactNative

Post, Code and Quiet Time. Fix Crash caused by TransactionTooLargeException in InterstitialAd.show() By Errong Leng – 15 May 2024 – View online → Photo by Tomáš Malík / Unsplash The issue since happened a few years back since 2019. as time went by, in 2024, I still faced this issue while testing my android app release version. 535 866 E ActivityTaskManager: Second failure launching com.lengerrong.coca/com.google.android.gms.ads.AdActivity, giving up 05-15 03:12:28.066 535 866 E ActivityTaskManager: android.os.TransactionTooLargeException: data parcel size 537904 bytes 05-15 03:12:28.066 535 866 E ActivityTaskManager: at android.os.BinderProxy.transactNative(Native Method) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at android.os.BinderProxy.transact(BinderProxy.java:571) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at android.app.IApplicationThread$Stub$Proxy.scheduleTransaction(IApplicationThread.java:2732) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at android.app.servertransaction.ClientTransaction.schedule(ClientTransaction.java:136) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at com.android.server.wm.ClientLifecycleManager.scheduleTransaction(ClientLifecycleManager.java:47) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at com.android.server.wm.ActivityTaskSupervisor.realStartActivityLocked(ActivityTaskSupervisor.java:868) 05-15 03:12:28.066 535 866 E ActivityTaskManager: at com.android.server.wm.RootWindowContainer.startActivityForAttachedApplicationIfNeeded(RootWindowContainer.java:1950) it seems like there are some data size limit while start activity via Intent and passing some extras. I searched on google, not able to see any way to increase the size, that seems like bind to android SDK. and Google Admob SDK team still not provided any fix either. With tests ad unit ids, everything works fine. I am not sure what will happen if release into production, since I donèt have a android device handy to do the test. Edit Ad unit type, Remove video I am thinking the issue is due to size limit, for the Ad content, it might consist of Text, image, and rich media and Video. Video elements might take big media buffer size. so I tried remove it and it works. In you admob account dashboard, open your App, edit the ad unit that might cause the issue. Edit the ad unit type, not select video or remove video and save the change. Though you might see warning: "Limiting ad types may result in decreased revenue", App stable is more important than AD revenue. because if your App always crash, then you will get zero. Crash caused by TransactionTooLargeException in InterstitialAd.show() Google Groups Post, Code and Quiet Time. © 2024 – Unsubscribe

Troubleshooting SSL/TLS Issues(java.security.NoSuchAlgorithmException) in Java Applications

Caused by: java.io.UncheckedIOException: java.io.IOException: java.security.NoSuchAlgorithmException: Error constructing implementation (algorithm: Default, provider: SunJSSE, class: sun.security.ssl.SSLContextImpl$DefaultSSLContext) at java.net.http/jdk.internal.net.http.HttpClientImpl.<init>(HttpClientImpl.java:285) ~[java.net.http:na] at java.net.http/jdk.internal.net.http.HttpClientImpl.create(HttpClientImpl.java:270) ~[java.net.http:na] at ... 49 common frames omitted Caused by: java.s

Post, Code and Quiet Time. Troubleshooting SSL/TLS Issues(java.security.NoSuchAlgorithmException) in Java Applications By Errong Leng – 15 May 2024 – View online → Photo by Tomáš Malík / Unsplash Caused by: java.io.UncheckedIOException: java.io.IOException: java.security.NoSuchAlgorithmException: Error constructing implementation (algorithm: Default, provider: SunJSSE, class: sun.security.ssl.SSLContextImpl$DefaultSSLContext) at java.net.http/jdk.internal.net.http.HttpClientImpl.<init>(HttpClientImpl.java:285) ~[java.net.http:na] at java.net.http/jdk.internal.net.http.HttpClientImpl.create(HttpClientImpl.java:270) ~[java.net.http:na] at ... 49 common frames omitted Caused by: java.security.KeyManagementException: null at java.base/sun.security.ssl.SSLContextImpl$DefaultManagersHolder.<clinit>(SSLContextImpl.java:942) ~[na:na] at java.base/sun.security.ssl.SSLContextImpl$DefaultSSLContext.<init>(SSLContextImpl.java:1111) ~[na:na] at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) ~[na:na] at java.base/jdk.internal.reflect Introduction:When working with Java applications that interact with secure servers over HTTPS, SSL/TLS-related errors can occur, causing disruptions to your application's functionality. One common error, java.security.NoSuchAlgorithmException, indicates a problem with SSL/TLS configuration. In this post, we'll explore one potential cause of this error and how to resolve it. Identifying the Issue:The java.security.NoSuchAlgorithmException error typically indicates that the SSL/TLS implementation is unable to find the specified algorithm. While there can be various underlying causes, one common issue is an incorrect or non-existent path to the truststore or keystore file. Possible Cause:If the truststore or keystore file path is incorrect, either due to a typo or non-existent file, the SSL/TLS implementation will fail to initialize properly, resulting in the NoSuchAlgorithmException error. Solution:To resolve this issue, ensure that you are providing the correct path to the truststore or keystore file. Here are the steps to follow: Verify File Paths: Double-check the paths to the truststore and keystore files in your Java application's configuration. Ensure that the paths are correct and the files exist at those locations. Correcting Typos: If there are any typos in the file paths, correct them to point to the right location of the truststore or keystore files. Update Configuration: Once you've verified and corrected the file paths, update your Java application's configuration to use the corrected paths. Example:Suppose you have the following configuration in your Java application: System.setProperty("javax.net.ssl.trustStore", "/path/to/truststore.jks"); or either via java vm args like -Djavax.net.ssl.keyStore=keystore.jks -Djavax.net.ssl.keyStorePassword=password If the file path /path/to/truststore.jks is incorrect or the file does not exist, you may encounter the NoSuchAlgorithmException error. Ensure that the correct path to the truststore file is provided. Conclusion:SSL/TLS-related errors can be challenging to troubleshoot, but by identifying and addressing common issues, such as incorrect file paths to truststore or keystore files, you can resolve them effectively. Always double-check your configuration and ensure that the paths provided are accurate and point to the correct files. Once you've corrected the paths, your Java application should be able to establish SSL/TLS connections without encountering the NoSuchAlgorithmException error. Post, Code and Quiet Time. © 2024 – Unsubscribe

How to Build a Release Version of Your React Native App for Android

Building a release version of your React Native app for Android is essential for distributing your app to users through app stores like Google Play. Here's a step-by-step guide on how to do it: 1. Generate a Signing Key Before you can build a release version of your app, you need to generate a signing key. You can do this using the keytool command that comes with the Java Development Kit (JDK). Open a terminal and run the following command: keytool -genkeypair -v -keystore your-key.keystore -

Post, Code and Quiet Time. How to Build a Release Version of Your React Native App for Android By Errong Leng – 11 May 2024 – View online → Photo by martin bennie / Unsplash Building a release version of your React Native app for Android is essential for distributing your app to users through app stores like Google Play. Here's a step-by-step guide on how to do it: 1. Generate a Signing Key Before you can build a release version of your app, you need to generate a signing key. You can do this using the keytool command that comes with the Java Development Kit (JDK). Open a terminal and run the following command: keytool -genkeypair -v -keystore your-key.keystore -alias your-alias -keyalg RSA -keysize 2048 -validity 10000 Replace your-key.keystore and your-alias with your desired file name and alias. Follow the prompts to enter the required information, including passwords and alias details. 2. Configure Gradle Properties Next, you need to configure your project's gradle.properties file. Open the android/gradle.properties file in your project and add the following lines: MYAPP_RELEASE_STORE_FILE=your-key.keystore MYAPP_RELEASE_KEY_ALIAS=your-alias MYAPP_RELEASE_STORE_PASSWORD=your-store-password MYAPP_RELEASE_KEY_PASSWORD=your-key-password Replace your-key.keystore, your-alias, your-store-password, and your-key-password with the appropriate values from the signing key you generated. 3. Configure Gradle Build Types Open the android/app/build.gradle file in your project and add the following code block inside the android block: signingConfigs { release { storeFile file(MYAPP_RELEASE_STORE_FILE) storePassword MYAPP_RELEASE_STORE_PASSWORD keyAlias MYAPP_RELEASE_KEY_ALIAS keyPassword MYAPP_RELEASE_KEY_PASSWORD } } buildTypes { release { signingConfig signingConfigs.release } } 4. Build the Release APK Now, you can generate the release APK by running the following command in the root of your project: cd android && ./gradlew assembleRelease This command will generate the release APK file in the android/app/build/outputs/apk/release directory of your project. 5. Testing the Release APK Before distributing your app, it's essential to test the release APK to ensure that it functions correctly. You can do this by installing the APK on a device or emulator and thoroughly testing all features. 6. Release Preparation Once you're satisfied with your app's release version, you can prepare it for distribution by following the guidelines of the app store where you plan to publish it. This usually involves creating a store listing, uploading screenshots, providing app descriptions, and setting pricing and availability options. 7. Distribution Finally, you can distribute your app by uploading the release APK to the app store's developer console. Follow the platform-specific guidelines for uploading and publishing your app. For Google Play, you'll need to sign in to the Google Play Console, create a new release, and upload your APK file. Conclusion Building a release version of your React Native app for Android involves several steps, including generating a signing key, configuring Gradle properties, and building the release APK. By following these steps and guidelines, you can prepare and distribute your app to users through app stores with confidence. Post, Code and Quiet Time. © 2024 – Unsubscribe

Setting Up a Static Server in React Native for Shared Assets

When working on a React Native app, you may have a bunch of assets that need to be served as static resources. These assets are often shared between Android and iOS apps, and are commonly placed in the root folder of your project. However, in Android, assets are typically expected to be located under src/main/assets. So, to serve these assets in both platforms, you'll need to tell the Android app to include them during the build step. 1. Organizing Your Project Structure First, make sure your

Post, Code and Quiet Time. Setting Up a Static Server in React Native for Shared Assets By Errong Leng – 11 May 2024 – View online → When working on a React Native app, you may have a bunch of assets that need to be served as static resources. These assets are often shared between Android and iOS apps, and are commonly placed in the root folder of your project. However, in Android, assets are typically expected to be located under src/main/assets. So, to serve these assets in both platforms, you'll need to tell the Android app to include them during the build step. 1. Organizing Your Project Structure First, make sure your assets are placed in a shared directory. For example, you can place them in the root folder of your project. project-root/ ├── android/ ├── ios/ ├── assets/ │ ├── images/ │ ├── fonts/ │ └── ... └── ... 2. Updating Android Build Configuration In your Android app's build.gradle file, add the shared assets directory to the list of asset source directories. android { sourceSets { main { assets.srcDirs += ['../../assets'] } } } This tells the Android app to include assets from the assets directory in the root folder of your project during the build process. 3. Creating a Static Server Now, let's set up a simple static server in your Android app to serve these assets. You can use NanoHTTPD for this purpose. import android.content.Context; import java.io.IOException; import java.io.InputStream; import fi.iki.elonen.NanoHTTPD; public class StaticServer extends NanoHTTPD { private Context context; public StaticServer(Context context) { super(8080); // You can change the port number if needed this.context = context; } @Override public Response serve(IHTTPSession session) { String uri = session.getUri(); try { InputStream inputStream = context.getAssets().open(uri.substring(1)); // remove leading '/' return newChunkedResponse(Response.Status.OK, getMimeType(uri), inputStream); } catch (IOException e) { return newFixedLengthResponse(Response.Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT, "File not found"); } } private String getMimeType(String uri) { if (uri.endsWith(".html")) { return "text/html"; } else if (uri.endsWith(".css")) { return "text/css"; } else if (uri.endsWith(".js")) { return "application/javascript"; } else if (uri.endsWith(".png")) { return "image/png"; } else if (uri.endsWith(".jpg") || uri.endsWith(".jpeg")) { return "image/jpeg"; } else { return "text/plain"; } } } In the StaticServer class, when we retrieve assets using context.getAssets().open(), you may notice the use of uri.substring(1). This is necessary because the URI always starts with a '/', and if we don't remove it, the assets manager will try to load the static file from the root directory, resulting in a file not found error. By using substring(1), we ensure that the URI correctly points to the asset within the assets directory. 4. Integrating the Server in Your App Now, integrate the static server into your app, start it in your activity, and remember to stop it when the activity is destroyed. import android.os.Bundle; import android.support.v7.app.AppCompatActivity; public class MainActivity extends AppCompatActivity { private StaticServer server; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); server = new StaticServer(getApplicationContext()); try { server.start(); } catch (IOException e) { e.printStackTrace(); } } @Override protected void onDestroy() { super.onDestroy(); if (server != null) { server.stop(); } } } Conclusion You've successfully set up a static server in your Android app to serve shared assets from the root folder of your project. This approach allows you to keep your assets organized and shared between both Android and iOS platforms. Stay tuned for our upcoming blog post on setting up a similar static server in an iOS app! Post, Code and Quiet Time. © 2024 – Unsubscribe