leakcanary stacktrace hard to understand

Question

I have the below stack trace from leak canary with which I am not sure how my Activity is getting leaked

static LGCobtextHelper.mLGContext
references LGContext.mContext
references
ResourcesContextWrapperFactory$WebViewContextWrapper.mBase
references
com.*.*.activity.MyActivity.networkMonitor
references
com.*.*.NetworkMonitor.mPendingResult
references
android.app.LoadedApk$ReceiverDispatcher$Args.this$0
references
LoadedAok$ReceiverDispathcer.mContext
leaks MyActivity instance

MyActivity extends BaseActivity, which registers onResume() and unregisters onPause(), so not sure which leaks the activity

NetworkMonitor.java

     public class NetworkMonitor extends BroadcastReceiver {
    private final WebSocketClient webSocketClient;
    private final ArmingHelper armingHelper;
    private final ShutdownManager shutdownManager;
    private final CameraThumbnailCache cameraThumbnailCache;
    private final CameraAccessManager cameraAccessManager;
    private final JoustLogger joustLogger;

    private Activity registeredActivity;
    private String currentNetworkName;
    private List<NetworkStatusChangeListener> networkChangeListeners;

    public interface NetworkStatusChangeListener {
        void onNetworkUp();
        void onNetworkDown();
    }

    public NetworkMonitor(WebSocketClient webSocketClient, ArmingHelper armingHelper, ShutdownManager shutdownManager, CameraThumbnailCache cameraThumbnailCache, CameraAccessManager cameraAccessManager, JoustLogger joustLogger) {
        this.webSocketClient = webSocketClient;
        this.armingHelper = armingHelper;
        this.shutdownManager = shutdownManager;
        this.cameraThumbnailCache = cameraThumbnailCache;
        this.cameraAccessManager = cameraAccessManager;
        this.joustLogger = joustLogger;
        networkChangeListeners = new ArrayList<>();
    }

    // Activities *must* call this method in onResume() in order for
    // the app to watch for network changes
    public void startListeningForNetworkChanges(Activity registeringActivity) {
        if (!(registeringActivity instanceof NetworkStatusChangeListener)) {
            throw new IllegalArgumentException("Registering Activity must implement NetworkStatusChangeListener");
        }

        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        intentFilter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED);
        intentFilter.addAction(GlobalConstants.ANDROID_NET_WIFI_WIFI_STATE_CHANGED);
        registeringActivity.registerReceiver(this, intentFilter);
        this.registeredActivity = registeringActivity;
        registerListenerForNetworkChanges((NetworkStatusChangeListener)registeringActivity);
    }

    // Activities *must* call this method in onPause() in order to properly
    // unregister the receiver that was set in onResume()
    public void stopListeningForNetworkChanges(Activity registeringActivity) {
        registeringActivity.unregisterReceiver(this);
        unregisterListenerForNetworkChanges((NetworkStatusChangeListener)registeringActivity);
        registeredActivity = null;
    }

    // Fragments can use this method to register for Network change updates, call in onResume()
    public void registerListenerForNetworkChanges(NetworkStatusChangeListener listener) {
        networkChangeListeners.add(listener);
    }

    // Fragments need to unregister in onPause()
    public void unregisterListenerForNetworkChanges(NetworkStatusChangeListener listener) {
        networkChangeListeners.remove(listener);
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        checkNetworkConnection();
    }

    public void checkNetworkConnection() {
        if (registeredActivity != null) {
            final ConnectivityManager connectivityManager = (ConnectivityManager) registeredActivity.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
            if (networkInfo != null && networkInfo.isConnectedOrConnecting()) {
                String newNetworkName = networkInfo.getTypeName();
                if (currentNetworkName == null || !currentNetworkName.equals(newNetworkName)) {
                    Timber.d("Network(%s) Connected", newNetworkName);
                    // Our network was down, but now it's up.  Validate the Websocket
                    currentNetworkName = newNetworkName;
                    cameraThumbnailCache.clearInternalURLPreferences();
                    webSocketClient.reopenWebsocketIfPossible();
                    cameraAccessManager.onNetworkUp();
                    if (ActivityBehaviorHelper.needsSecurityCountdown(registeredActivity)) {
                        armingHelper.startTimerIfReady();
                    }
                    for (NetworkStatusChangeListener listener : networkChangeListeners) {
                        listener.onNetworkUp();
                    }
                    joustLogger.onNetworkUp();
                }
            } else {
                Timber.w("Network Down");
                currentNetworkName = null;
                cameraAccessManager.onNetworkDown();
                joustLogger.onNetworkDown();
                shutdownManager.onNetworkDown();
                for (NetworkStatusChangeListener listener : networkChangeListeners) {
                    listener.onNetworkDown();
                }
            }
        }
    }
}


BaseActivity.java

   @Override
    protected void onResume() {
        super.onResume();
        networkMonitor.startListeningForNetworkChanges(this);
    }

    @Override
    protected void onPause() {
        networkMonitor.stopListeningForNetworkChanges(this);
        super.onPause();
    }

Answer 1

It looks like you probably don't need to be holding a reference to the Activity in that NetworkMonitor class. That's probably the source of your memory leak - the Activity reference is likely being held after the Activity is destroyed. Looks like you could just pass the context in as a parameter to the methods that need it.

Also, For a few of the spots where Activity context is being used here, like context.getSystemService(Context.CONNECTIVITY_SERVICE), you could use Application context instead and possibly avoid needing an Activity reference altogether.