If you have ever tried to place more than one map fragment in a view pager contained inside a parent fragment to form a tab layout. You must have encountered a random crash in your app. The crash log will look something like the following:

  
    E/AndroidRuntime﹕ FATAL EXCEPTION: GLThread 9994
    java.lang.NullPointerException: Attempt to get length of null array
      at java.nio.DirectByteBuffer.put(DirectByteBuffer.java:385)
      at java.nio.ByteBufferAsIntBuffer.put(ByteBufferAsIntBuffer.java:160)
      at com.google.maps.api.android.lib6.gmm6.o.c.a.k.e(Unknown Source)
  

The crash also seems to happen randomly and not every time. It might get triggered at a certain location or coordinates and you would end up scratching your head, what's causing it. Apparently even Google is aware of this and the bug is being tracked here. The bug has existed since the Lollipop days and still occurs on newer versions. I myself have faced the bug on Android Nougat and Pie.

I have tried a number of solutions that have been listed on sites like StackOverflow but none of them seemed to help in my case. It was really frustrating to figure out if a solution did actually work, because at times I would think the app has stopped crashing but on the 9th or 10th launch it would crash again. I started to think differently and instead of fixing the bug itself I thought of catching the crash? How did I do that? Well let's find out

The Solution

Most of the programmers will be familiar with the try-catch terminology. The try statement allows you to define a block of code to be tested for errors while it is being executed. And the catch statement allows you to define a block of code to be executed, if an error occurs in the try block. According to the crash log, the crash is due to a NullPointerException and it occurs on the GLThread. What we need to do is, to override the default uncaught exception handler so that we can suppress crashing the app when this certain exception occurs.

We need to add the following block of code in the onCreate method of the activity in which the parent fragment for these map fragments resides:

  
  final UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread thread, Throwable ex) {
        if (ex instanceof NullPointerException && thread.getName().startsWith("GLThread")) {
            for (StackTraceElement stackTraceElement : ex.getStackTrace()) {
                if (stackTraceElement.getClassName().contains("maps")) {
                  Intent intent = new Intent("crash-broadcast");
                  intent.putExtra("Map Crash", "Yes");
                  LocalBroadcastManager.getInstance(getBaseContext()).sendBroadcast(intent);

                  return;
                }
            }
        }
        defaultHandler.uncaughtException(thread, ex);
    }
});
  

Now when the exception will occur, you can control what to do. You must have noticed that I am using the broadcast manger to send a local broadcast. Stopping the app from crashing is only half the solution, we also need to re-draw or re-create the map fragments in order to make them usable. Since the crash occurs on the GLThread which is responsible for drawing the maps, you'll notice that the maps will look jittery or won't response at all. So we also need a way to re-initiate the maps.

In the child fragments that are using the Google Maps fragment we can recieve the broadcast sent from the parent activity and do the following:

    
        private BroadcastReceiver mMessageReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
            String mapCrash = intent.getStringExtra("Map Crash");

            if(mapCrash != null) {
              Fragment mapFragment = getChildFragmentManager().findFragmentById(R.id.fragmentFrameLayout);
                if (mapFragment != null) {
                    getChildFragmentManager().beginTransaction()
                            .replace(R.id.fragmentFrameLayout, SupportMapFragment.newInstance())
                            .commit();
             
                    final Handler handler = new Handler();
                    handler.postDelayed(new Runnable() {
                        @Override
                        public void run() {
                            if (map == null) {
                                handler.postDelayed(this, 100);
                            }
                        }
                    }, 100);
                 }
              }
            }
        };
    
  

This was my approach on tackling with this crash, let me know what you guys think and which methods have you tried yourself. Cheers