Essential Books

Avoid leaking Activities with Listeners

suggest change

If you implement or create a listener in an Activity, always pay attention to the lifecycle of the object that has the listener registered.

Consider an application where we have several different activities/fragments interested in when a user is logged in or out. One way of doing this would be to have a singleton instance of a UserController that can be subscribed to in order to get notified when the state of the user changes: 

public class UserController {
    private static UserController instance;
    private List<StateListener> listeners;

    public static synchronized UserController getInstance() {
        if (instance == null) {
            instance = new UserController();
        }
        return instance;
    }

    private UserController() {
        // Init
    }

    public void registerUserStateChangeListener(StateListener listener) {
        listeners.add(listener);
    }

    public void logout() {
        for (StateListener listener : listeners) {
            listener.userLoggedOut();
        }
    }

    public void login() {
        for (StateListener listener : listeners) {
            listener.userLoggedIn();
        }
    }

    public interface StateListener {
        void userLoggedIn();
        void userLoggedOut();
    }
}

Then there are two activities, SignInActivity: 

public class SignInActivity extends Activity implements UserController.StateListener{

    UserController userController;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        this.userController = UserController.getInstance();
        this.userController.registerUserStateChangeListener(this);
    }

    @Override
    public void userLoggedIn() {
        startMainActivity();
    }

    @Override
    public void userLoggedOut() {
        showLoginForm();
    }

    ...

    public void onLoginClicked(View v) {
        userController.login();
    }
}

And MainActivity: 

public class MainActivity extends Activity implements UserController.StateListener{
    UserController userController;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        this.userController = UserController.getInstance();
        this.userController.registerUserStateChangeListener(this);
    }

    @Override
    public void userLoggedIn() {
        showUserAccount();
    }

    @Override
    public void userLoggedOut() {
        finish();
    }

    ...

    public void onLogoutClicked(View v) {
        userController.logout();
    }
}

What happens with this example is that every time the user logs in and then logs out again, a MainActivity instance is leaked. The leak occurs because there is a reference to the activity in UserController#listeners.

Please note: Even if we use an anonymous inner class as a listener, the activity would still leak: 

...
this.userController.registerUserStateChangeListener(new UserController.StateListener() {
    @Override
    public void userLoggedIn() {
        showUserAccount();
    }

    @Override
    public void userLoggedOut() {
        finish();
    }
});    
...

The activity would still leak, because the anonymous inner class has an implicit reference to the outer class (in this case the activity). This is why it is possible to call instance methods in the outer class from the inner class. In fact, the only type of inner classes that do not have a reference to the outer class are static inner classes.

In short, all instances of non-static inner classes hold an implicit reference to the instance of the outer class that created them.

There are two main approaches to solving this, either by adding a method to remove a listener from UserController#listeners or using a WeakReference to hold the reference of the listeners.

Alternative 1: Removing listeners

Let us start by creating a new method removeUserStateChangeListener(StateListener listener): 

public class UserController {

    ...

    public void registerUserStateChangeListener(StateListener listener) {
        listeners.add(listener);
    }

    public void removeUserStateChangeListener(StateListener listener) {
        listeners.remove(listener);
    }

    ...
}

Then let us call this method in the activity’s onDestroy method: 

public class MainActivity extends Activity implements UserController.StateListener{
    ...

    @Override
    protected void onDestroy() {
        super.onDestroy();
        userController.removeUserStateChangeListener(this);
    }
}

With this modification the instances of MainActivity are no longer leaked when the user logs in and out. However, if the documentation isn’t clear, chances are that the next developer that starts using UserController might miss that it is required to unregister the listener when the activity is destroyed, which leads us to the second method of avoiding these types of leaks.

Alternative 2: Using weak references

First off, let us start by explaining what a weak reference is. A weak reference, as the name suggests, holds a weak reference to an object. Compared to a normal instance field, which is a strong reference, a weak references does not stop the garbage collector, GC, from removing the objects. In the example above this would allow MainActivity to be garbage-collected after it has been destroyed if the UserController used WeakReference to the reference the listeners.

In short, a weak reference is telling the GC that if no one else has a strong reference to this object, go ahead and remove it.

Let us modify the UserController to use a list of WeakReference to keep track of it’s listeners: 

public class UserController {

    ...
    private List<WeakReference<StateListener>> listeners;
    ...

    public void registerUserStateChangeListener(StateListener listener) {
        listeners.add(new WeakReference<>(listener));
    }

    public void removeUserStateChangeListener(StateListener listenerToRemove) {
        WeakReference referencesToRemove = null;
        for (WeakReference<StateListener> listenerRef : listeners) {
            StateListener listener = listenerRef.get();
            if (listener != null && listener == listenerToRemove) {
                referencesToRemove = listenerRef;
                break;
            }
        }
        listeners.remove(referencesToRemove);
    }

    public void logout() {
        List referencesToRemove = new LinkedList();
        for (WeakReference<StateListener> listenerRef : listeners) {
            StateListener listener = listenerRef.get();
            if (listener != null) {
                listener.userLoggedOut();
            } else {
                referencesToRemove.add(listenerRef);
            }
        }
    }

    public void login() {
        List referencesToRemove = new LinkedList();
        for (WeakReference<StateListener> listenerRef : listeners) {
            StateListener listener = listenerRef.get();
            if (listener != null) {
                listener.userLoggedIn();
            } else {
                referencesToRemove.add(listenerRef);
            }
        }
    }
    ...    
}

With this modification it doesn’t matter whether or not the listeners are removed, since UserController holds no strong references to any of the listeners. However, writing this boilerplate code every time is cumbersome. Therefore, let us create a generic class called WeakCollection: 

public class WeakCollection<T> {
    private LinkedList<WeakReference<T>> list;

    public WeakCollection() {
        this.list = new LinkedList<>();
    }
    public void put(T item){
        //Make sure that we don't re add an item if we already have the reference.
        List<T> currentList = get();
        for(T oldItem : currentList){
            if(item == oldItem){
                return;
            }
        }
        list.add(new WeakReference<T>(item));
    }

    public List<T> get() {
        List<T> ret = new ArrayList<>(list.size());
        List<WeakReference<T>> itemsToRemove = new LinkedList<>();
        for (WeakReference<T> ref : list) {
            T item = ref.get();
            if (item == null) {
                itemsToRemove.add(ref);
            } else {
                ret.add(item);
            }
        }
        for (WeakReference ref : itemsToRemove) {
            this.list.remove(ref);
        }
        return ret;
    }

    public void remove(T listener) {
        WeakReference<T> refToRemove = null;
        for (WeakReference<T> ref : list) {
            T item = ref.get();
            if (item == listener) {
                refToRemove = ref;
            }
        }
        if(refToRemove != null){
            list.remove(refToRemove);
        }
    }
}

Now let us re-write UserController to use WeakCollection<T> instead: 

public class UserController {
    ...
    private WeakCollection<StateListener> listenerRefs;
    ...

    public void registerUserStateChangeListener(StateListener listener) {
        listenerRefs.put(listener);
    }

    public void removeUserStateChangeListener(StateListener listenerToRemove) {
        listenerRefs.remove(listenerToRemove);
    }

    public void logout() {
        for (StateListener listener : listenerRefs.get()) {
            listener.userLoggedOut();
        }
    }

    public void login() {
        for (StateListener listener : listenerRefs.get()) {
            listener.userLoggedIn();
        }
    }

    ...
}

As shown in the code example above, the WeakCollection<T> removes all of the boilerplate code needed to use WeakReference instead of a normal list. To top it all off: If a call to UserController#removeUserStateChangeListener(StateListener) is missed, the listener, and all the objects it is referencing, will not leak.

Found a mistake? Have a question or improvement idea? Let me know.

Feedback about page:

Feedback:
Optional: your email if you want me to get back to you:

Memory Leaks:
* Memory Leaks
* Avoid leaking Activities with AsyncTask
* Common memory leaks and how to fix them
* Detect memory leaks with the LeakCanary library
* Anonymous callback in activities
* Activity Context in static classes
* Avoid leaking Activities with Listeners
* Avoid memory leaks with Anonymous Class Handler Timer Task Thread
Table Of Contents
0 Getting Started
1 Layouts
2 Gradle
3 RecyclerView onClickListeners
4 NavigationView
5 Intent
6 JSON handling with org.json
7 Android Studio
8 Resources
9 Data Binding Library
10 Exceptions
11 Getting Calculated View Dimensions
12 AsyncTask
13 SharedPreferences
14 Emulator
15 Material Design
16 Lint Warnings
17 Service
18 Storing Files in Internal and External Storage
19 WebView
20 Project SDK versions
21 RecyclerView
22 Google Maps
23 PorterDuff Mode
24 9-Patch images
25 Android NDK
26 RecyclerView Decorations
27 Camera 2 API
28 ViewPager
29 CardView
30 HttpURLConnection
31 SQLite
32 ADB Android Debug Bridge
33 ButterKnife
34 Supporting different screen resolutions
35 Glide
36 Retrofit2
37 Dialog
38 ACRA
39 GreenDAO
40 Formatting Strings
41 Notifications
42 AlarmManager
43 Fragments
44 Handler
45 Creating Custom Views
46 BroadcastReceiver
47 Activity
48 Snackbar
49 Runtime Permissions in API-23
50 Logging and using Logcat
51 VectorDrawable and AnimatedVectorDrawable
52 Tools Attributes
53 Toast
54 Interfaces
55 Animators
56 Location
57 Theme Style Attribute
58 The Manifest File
59 Parcelable
60 MediaPlayer
61 Multidex and the Dex Method Limit
62 Data Synchronization with Sync Adapter
63 Menu
64 Instant Run in Android Studio
65 Picasso
66 Bluetooth LE API
67 RoboGuice
68 Memory Leaks
69 Universal Image Loader
70 Volley
71 Widgets
72 Date and Time Pickers
73 Integrate Google Sign In
74 In-app billing
75 FloatingActionButton
76 ContentProvider
77 Dagger 2
78 Realm
79 Unit testing in Android with JUnit
80 Android Versions
81 Wi-Fi Connections
82 SensorManager
83 Localization with resources
84 ProgressBar
85 Custom Fonts
86 Vibration
87 Google Awarness APIs
88 Text to Speech (TTS)
89 UI Lifecycle
90 Spinner
91 Data Encryption / Decryption
92 Testing UI with Espresso
93 Writing UI tests
94 GreenRobot EventBus
95 OkHttp
96 Enhancing Performance Using Icon Fonts
97 Handling Depp Links
98 Canvas drawing using SurfaceView
99 Firebase
100 Crash Reporting Tools
101 Check Internet Connectivity
102 Facebook SDK
103 Unzip File
104 Android Places API
105 Creating your own libraries
106 Handling JSON with Gson
107 Device Display Metrics
108 TextView
109 ListView
110 Building Backwards Compatible Apps
111 Loader
112 ProGuard - Obfuscating and Shrinking your code
113 Detect Shake Event
114 Typedef Annotations
115 Capturing Screenshots
116 MVP Architecture
117 Orientation Changes
118 Xposed
119 Security
120 PackageManager
121 ImageView
122 Gesture Detection
123 Doze Mode
124 Android Sound and Media
125 SearchView
126 Camera and Gallery
127 Callback URL
128 Twitter APIs
129 SqlCipher integration
130 Drawables
131 Colors
132 ConstraintLayout
133 RenderScript
134 Fresco
135 Swipe to Refresh
136 AutoCompleteTextView
137 Installing apps with ADB
138 IntentService
139 AdMob
140 Implicit Intents
141 Publish to Play Store
142 Firebase Realtime Database
143 Image Compression
144 Email Validation
145 Keyboard
146 Button
147 TextInputLayout
148 Bottom Sheets
149 CoordinatorLayout and Behaviors
150 EditText
151 Paypal Gateway Integration
152 Firebase App Indexing
153 Firebase Crash Reporting
154 Displaying Google Ads
155 Vk SDK
156 Localized DateTime
157 Count Down Timer
158 Reading Barcode and QR codes
159 Otto Event Bus
160 TransitionDrawable
161 Port Mapping using Cling
162 Creating Overlay always-on-top Windows
163 ExoPlayer
164 Inter-app UI testing with UIAutomator
165 MediaSession
166 Speech to Text Conversion
167 FileProvider
168 Publish .aar file to Apache Archive with Gradle
169 XMPP
170 Authenticator
171 RecyclerView and LayoutManagers
172 AudioManager
173 Job Scheduling
174 Accounts and AccountManager
175 OpenCV
176 Split Screen Multi-Screen Activities
177 Threads
178 MediaStore
179 Time Utils
180 Touch Events
181 Fingerprint API
182 MVVM Architecture
183 BottomNavigationView
184 ORMLite
185 YouTube API
186 TabLayout
187 Retrofit2 with RxJava
188 DayNight Theme AppCompat
189 ShortcutManager
190 LruCache
191 Using Jenkins CI
192 Zip files
193 Vector Drawables
194 Fastlane
195 Define step value for RangeSeekBar
196 Getting started with OpenGL ES 2.0
197 Check Data Connection
198 Java Native Interface (JNI)
199 FileIO
200 Perfomance Optimization
201 Robolectric
202 Moshi
203 Strick Mode Policy
204 Internalization and localization
205 Retrolambda
206 SparseArray
207 Firebase Cloud Messaging
208 Shared Element Transitions
209 Android Things
210 VideoView
211 ViewFlipper
212 Dependency Injection with Dagger 2
213 Formatting phone numbers
214 Storing password securely
215 Android Kernel Optimization
216 Paint
217 AudioTrack
218 ProGuard
219 Create Android Custom ROMs
220 Java on Android
221 Pagination in RecyclerVi
222 Genymotion for Android
223 Handling touch and motion events
224 Creating Splash screen
225 ConstraintSet
226 CleverTap
227 Publish library to Maven repositories
228 ADB shell
229 Ping ICMP
230 AIDL
231 Using Kotlin
232 Autosizing TextView
233 Signing apps for release
234 Context
235 Activity Recognition
236 Secure SharedPreferences
237 Secure SharedPreferences
238 Bitmap Cache
239 Android x86 in VirtualBox
240 JCodec
241 Design Patterns
242 Okio
243 Google SignIn integration
244 TensorFlow
245 Game developmen
246 Notification Channel
247 Bluetooth Low Energy (LE)
248 Leak Canary
249 FuseView
250 SQLite using ContentValues
251 Enhancing Alert Dialogs
252 Hardware Button Events, Intents PTT
253 SpannableString
254 Looper
255 Optimized VideoView
256 Google Drive API
257 Animated AlertDialog Box
258 Annotation Processor
259 SyncAdapter with periodically do sync of data
260 Singleton Class for Toast Message
261 Fastjson
262 Android Architecture Components
263 Jackson
264 Play Store
265 Loading Bitmaps Effectively
266 Getting system font names
267 Smartcard
268 Convert vietnamese string to english
269 Contributors