San Song Daddy :)

Fix Crash caused by TransactionTooLargeException in InterstitialAd.show()

By Errong Leng – 15 May 2024 – View online →

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.

remove video

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

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

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.

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

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.

Setting Up a Static Server in React Native for Shared Assets

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!

Building a Simple Static Server in an Android App for React Native

Post, Code and Quiet Time.

Building a Simple Static Server in an Android App for React Native

By Errong Leng – 10 May 2024 – View online →

Photo by Karsten Winegeart / Unsplash

If you're developing a React Native app and need to serve static assets such as images and HTML files, you may encounter challenges, as React Native apps typically don't serve any backend. In such cases, a simple static server running within your Android app can be very useful.

1. Setup

First, add the NanoHTTPD dependency to your project's build.gradle file:

dependencies {      implementation 'org.nanohttpd:nanohttpd:2.3.1'  }

This will automatically download and include NanoHTTPD in your project.

2. Creating the Static Server

Now, let's create a class that extends NanoHTTPD and overrides the serve() method to serve static files from your app's assets directory.

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));              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";          }      }  }

3. Starting the Server

Finally, start the server in your activity's onCreate() method and stop it in the onDestroy() method.

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 created a simple static server in your Android app! This server can serve static files such as HTML, CSS, JavaScript, images, etc., directly from your app's assets directory. This approach is particularly convenient for React Native apps that have a lot of static assets to serve, as bundling them during build time may not be ideal due to various reasons, and dynamic importing might not be feasible.

Stay tuned for our upcoming blog post on setting up a similar static server in an iOS app!

San Song Daddy :)

Fix Crash caused by TransactionTooLargeException in InterstitialAd.show()

Edit Ad unit type, Remove video

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

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

1. Generate a Signing Key

2. Configure Gradle Properties

3. Configure Gradle Build Types

4. Build the Release APK

5. Testing the Release APK

6. Release Preparation

7. Distribution

Conclusion

Setting Up a Static Server in React Native for Shared Assets

1. Organizing Your Project Structure

2. Updating Android Build Configuration

3. Creating a Static Server

4. Integrating the Server in Your App

Conclusion

Building a Simple Static Server in an Android App for React Native

1. Setup

2. Creating the Static Server

3. Starting the Server

Conclusion

fixed: embedded-redis: Unable to run on macOS Sonoma

Report Abuse

Labels