android Notifications in Android 8.1 Last time I wrote about notification channels [https://blog.danlew.net/2017/09/06/working-with-android-notification-channels/] I described a complicated solution to create the best balance between automatic bundling vs. not annoying the daylights out of the user: > * Have as few channels as possible make noise by default. * Use summaries
android Year in Review (2017) ICYMI (or more likely, in case I want a reference), here's all the public stuff I've done in the past year. This year, I purposefully avoided traveling to speak at conferences. Writing talks, traveling, and attending conferences takes up a huge chunk of time and I
android Working With Android Notification Channels Google has introduced notification channels [https://developer.android.com/preview/features/notification-channels.html] to Android Oreo. Each notification is now associated with a channel, and the user is granted control over how each channel presents notifications. For developers, channels are a double-edged sword. On the one hand, it is great
rxjava Why Not RxLifecycle? Hello. This is Dan Lew. You may or may not know me as the author of RxLifecycle [https://github.com/trello/RxLifecycle/tree/2.x]. Here’s why I’ve started pulling back from using my creation. Origins When Trello first started using RxJava [https://github.com/ReactiveX/RxJava], we
talk An Introduction to Functional Reactive Programming I gave a talk this year about functional reactive programming (FRP) that attempted to break down what gives FRP its name and why you should care. Here's a write-up of that talk. -------------------------------------------------------------------------------- Introduction Functional reactive programming has been all the rage in the past few years. But
kotlin Convincing the Kotlin compiler that code is safe One of the best features of Kotlin is its built-in null safety in the type system. Try to use a nullable type in a non-null way and the compiler will yell at you. This null safety can occasionally create some tricky situations, though. Code that you know is ironclad turns
kotlin Musings on Kotlin Ranges Here are a few interesting aspects of Kotlin ranges [https://kotlinlang.org/docs/reference/ranges.html], some of which I've found to be less-than-intuitive. Ranging on Empty Pop quiz: What does the following code output? (1..3).forEach(System.out::print) (3..1).forEach(System.out::print) If
kotlin Mutable vals in Kotlin When I first learned Kotlin, the difference between val and var seemed simple: val means immutable and var means mutable. The truth is more nuanced than that: val does not mean immutable, val means read-only. That means that you're not allowed to explicitly write to a val, but
kotlin Why Kotlin? I want to explain why I prefer Kotlin over Java. In short, the many myriad Kotlin features enable more concise and understandable code than Java without sacrificing performance or safety. Kotlin compiles to bytecode, so it can perform just as well as Java. It's got the same compile-time
android Proper Parcelable testing Check out this Parcelable [https://developer.android.com/reference/android/os/Parcelable.html] I've just written: public class Thing implements Parcelable { public static final Parcelable.Creator<Thing> CREATOR = new Parcelable.Creator<Thing>() { public Thing createFromParcel(Parcel in) { throw new RuntimeException("Oops"); } // ...skipping
android Displaying Sync State This article is part 7 of a series (1, 2, 3, 4, 5, 6, 7) Early on, we realized that we needed some way to communicate to the user when data isn’t synced with the server yet. Otherwise, you could end up in a frustrating situation where you see
android Sync is a Two-Way Street This article is part 6 of a series (1, 2, 3, 4, 5, 6, 7) Most of what I’ve written so far has been about uploading changes from the client to the server. But we found it is equally important to download changes from the server periodically, too. What
android Kotlin Puzzler: Whose Line Is It Anyways? Here's a small Kotlin puzzler. What's wrong with the following code (when used on Android)? val map = mapOf("hello" to "goodbye") map.forEach { t, u -> Log.i("tag", t + u) } I'll give you a hint: on
android Offline Attachments This article is part 5 of a series (1, 2, 3, 4, 5, 6, 7) When writing offline mode, attachments proved to be a uniquely difficult aspect of syncing. The nature of attachments differ from other data in Trello. Most data in Trello are simple numbers and strings. Files are
android The Two ID Problem This article is part 4 of a series (1, 2, 3, 4, 5, 6, 7) I want to call out a surprisingly tricky problem we ran into when developing offline mode: handling identifiers. In Trello, all models have an ID. Each board, list, card, etc. It’s how we define
android Sync Failure Handling This article is part 3 of a series (1, 2, 3, 4, 5, 6, 7) In the last article we discussed how we sync our changes with the server. Ideally, those HTTP requests would always work - if only we could walk the rosy path of best-case scenarios! Unfortunately, when
android Syncing Changes This article is part 2 of a series (1, 2, 3, 4, 5, 6, 7) Going offline meant using our database for all immediate changes to the client. But obviously we later want to sync those changes with the server. The basic idea behind our sync is to store changes
android Airplane Mode: Enabling Trello Mobile Offline This article is part 1 of a series (1, 2, 3, 4, 5, 6, 7) Good news, everyone! The Trello mobile apps now work offline! Offline mode has been the most requested mobile feature for years. It’s frustrating to lose the ability to use Trello when you enter the
android Correctly handling bundled Android notifications Bundled notifications on Android are a tricky business. Individual, fire-and-forget notifications are simple. You create a Notification [https://developer.android.com/reference/android/app/Notification.html], send it to NotificationManagerCompat [https://developer.android.com/reference/android/support/v4/app/NotificationManagerCompat.html] , and the system handles the rest. Bundled notifications allow
Code Deliberately All code should have a purpose. There should be just as much code as necessary to execute your goals and no more. Unintentional or unnecessary code raises many difficult questions: What is the purpose of this code? Is this code actually important? Did this code ever work? By contrast, intentional
android The Activity lifecycle vs. the world A common problem people run into with Activities are handling runtime configuration changes [http://developer.android.com/guide/topics/resources/runtime-changes.html]. This situation ought to sound familiar: 1. The user initiates a network request in an Activity. 2. The user rotates the screen. 3. The Activity is destroyed and
android Year in Review (2016) In case you missed it... here is all the public activity I've done in the last year. Articles * RxJava's repeatWhen and retryWhen, explained [https://blog.danlew.net/2016/01/25/rxjavas-repeatwhen-and-retrywhen-explained/] I found repeatWhen and retryWhen to be a couple of the most confusing RxJava operators,
android Trello Android Schema Upgrades For many years, Trello Android has used a simple system for upgrading the database schema: drop the entire database, recreate it, and repopulate the data from the server! While far from ideal, this solution worked because the Trello server was the only source of truth. Any change you made in
android A deep dive into Android View constructors I often see confusion around Android View constructors. Why are there four of them? What does each parameter do? Which constructors do I need to implement? tl;dr If you just want quick, practical advice, here's a few good guidelines: * Use View(Context) for creating Views in code.
rxjava Multicasting in RxJava Multicasting is a key method for reducing duplicated work in RxJava. When you multicast an event, you send the same event to all downstream operators/subscribers. This is useful when you're doing an expensive operation like a network request. You don't want to repeatedly execute identical
