サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
大谷翔平
proandroiddev.com
Bluetooth is an immensely fun technology to work with. Once you learn how to search for and communicate with devices, you will be surprised by how many of them there are out there and how much data you can get. And of course Android is a brilliant platform for working with it. …But, my goodness, is it a hard master to work with! I genuinely have never worked with an Android technology so full of c
I feel like I need to discuss this, so I decided to write an article on a hot topic in the Kotlin dev community about one-off events antipatterns. So the story begins with this article by Manuel Vivo ViewModel: One-off event antipatterns I recommend that you read the article and especially the comments to understand the situation fully, but I’ll summarize the article: Manuel Vivo argues that one-o
Image by justinmindSplash screen is a screen that loads when you launch an app. When you first open your application, a loading screen, also known as a launch screen or startup screen, appears. You’ll be brought to a more useful screen where you can perform activities after the loading is complete. Splash screens only appear briefly on your screen; if you turn your head away, you can miss them. Ty
Much has happened since both our articles were published. Jetpack Compose has come roaring on to the scene with its dramatically different take on UI. With it has come some very opinionated guidance from Google on the different communication patterns that an app should adopt and the way that data flows between the UI and the view model. This article is going to focus on Google’s new guidance with
Merry Christmas to all! The subject of this article is one that has been on my mind for a very long time. After all, “Clean Architecture” is often seen as the end goal, the hallmark of the finest of Android application code structure — it is the best of the very best. The name itself, “Clean Architecture”, signals that it’s a good thing ~ after all, who wants to work with “messy” code in compariso
Kotlin Coroutines recently introduced two Flow types, SharedFlow and StateFlow, and Android’s community started wondering about the possibilities and implications of substituting LiveData with one of those new types, or both. The two main reasons for that are: LiveData is closely bound to UI (no natural way to offload work to worker threads), andLiveData is closely bound to the Android platform.We
Pic by Tania MT with ❤What is buildSrcbuildSrc is a directory at the Gradle project root, which can contain our build logic. This allows us to use the Kotlin DSL to write our custom build code with very little configuration and share this logic across the whole project. This has become very popular in recent years and it is a common practice to define project-specific tasks or storing dependencies
Three years ago at a Google I/O that every Android developer remembers, Google announced Android Architecture Components and we were all excited about it. ACC has definitely changed the way we build Android Applications. ViewModel and LiveData have both taken an important place in our day-to-day app design. LiveData is the main topic of this post. Don’t get me wrong LiveData is a very powerful and
Choosing a dependency framework for your Android app is a big decision, it’s not something that you can easily replace later on. Dependency injection spans all layers of your app so it’s important that the DI framework that you choose meets all your requirements and that includes testing. I am going to compare 4 popular frameworks: Dagger, Koin, Kodein, and Toothpick. It’s interesting that all of
I’m a big fan of determinism. It’s part of why I love Kotlin as a programming language. I like pushing problems to the compiler. I like using types for expressiveness and safety. And I really like sealed classes for representing state. One of the tools in Kotlin that allows us to achieve greater determinism is the language’s when expression. Most programmers working in Kotlin are pretty familiar w
(This is a cross-post from SoundCloud’s developer blog) At KotlinConf’19 I talked about the power of types. In essence, I discussed limiting the number of primitives we use in our code in favor of using custom types instead. In this way, we as developers will not only reduce the possibility of bugs by using the compiler, but we will also achieve more readable and self-documented types. Today I ran
SourceIntroductionHandler and Looper are one of the main low-level Android OS things, which almost nobody uses directly (at least nowadays). But they are at the core, so many other high-level solutions are based on them. Therefore one should know what Handler and Looper are, what and how they are doing. In this article we’ll try to understand Handler and Looper in Android. What, how and why we mig
Since Clean Architecture became the new hot topic in the Android world there have been loads of code samples and articles that tried to explain how it works and which are its benefits. However, I always hear these questions from developers that try to apply it: What are these Use Cases/interactors supposed to do? Why can’t I call directly the repository from the Presenter/ViewModel? Why should I h
A Pixel 3 was the device used to test it. All images are visible at the same time, so these are requested almost at the same time and therefore, will be loaded almost in parallel. Two kinds of tests have been done: The time it takes to load every single image. In order to have more accurate data, images are being downloaded ten times, so the average will be taken into account.The time it takes to
Repository PatternOver the years I’ve seen many implementations of the repository pattern, yet I think most of them are wrong and not beneficial. These 5 are the most common mistakes I’ve seen (some of these are also in the official android documentation): The Repository returns a DTO instead of a Domain Model.DataSources (ApiServices, Daos..) use the same DTO.There is a Repository per set of endp
Let’s define a task firstImagine we have to make an app that shows basic info about a video file: container and video codec info and a frame size. Also we would like to actually display a frame from the video. We could show info about audio and subtitles too, but let’s keep focus on video only. How can we solve it with FFmpeg? We have two options: Use already existed Java library that wraps prebui
This post is a little more low-level than my recent posts about Kotlin Pearls, so brace yourself to a tour on the inner workings of Kotlin. Part I — the surpriseIt started with a (mostly) harmless piece of code. I wanted to show why it is not right to assume that List in Kotlin is immutable. The reason is that MutableList inherits from List: public interface MutableList<E> : List<E>, MutableCollec
Starting from version 1.2.0-alpha-2 of coroutines, the library will be adding a new type called Flow which is an abstraction for a cold stream. To understand what this means and why it is needed, it is pertinent to get the difference between a hot stream vs a cold stream. What is a cold streamCurrently, a stream of items can be transferred using a Channel<T>. For example using the produce coroutin
Whats is Flare? Flare is an online tool helps you to design and animate Vector Graphics, for Apps, Games, and Web, Flare by 2dimensions.com It’s not easy to get a rich animation on mobile, if you know Lottie and the Bodymovin plugin for After Effects, you can get rich and beautiful animation, but in my opinion, it’s better to use a complete solution supported by one company than using a tool like
Difference between Data Flow & Dependency RuleHello everyone! 👋 In this story I want to explain Clean Architecture (with tested examples) & talk about the most common mistake when adopting it (the difference between Data Flow and Dependency Rule). This story is the follow up after my latest medium Intro to App Architecture. Make sure to check it out if you are interested in what makes a good Arch
Last week I gave a talk at MobOS about writing and automating performance tests in Android. As part of the talk I wanted to demonstrate how you could detect memory leaks during your integration tests. To prove that, I created an Activity using Kotlin that was supposed to leak memory but for some reason it didn’t. Was Kotlin helping me out without me knowing it? Before I begin, the code of this art
Over the past few months I’ve been working on the initial release of a new tool, Window. This app overlays rulers and grids on screen, along with info on placement of views within your view hierarchy. The goal of this project is to reduce the time it takes to VQA. VQA? Visual Quality Assurance a.k.a. Pixel Pushing a.k.a. Pulling your hair out for that 1 pixel 😵. The VQA process is slowBefore the
Coroutines are a great way to write asynchronous code that is perfectly readable and maintainable. Kotlin provides the building block of asynchronous programming with a single language construct: the suspend keyword, along with a bunch of library functions that make it shine. In this post, I’ll try to explain in simple words the basics of coroutines and suspending functions. In order to keep it sh
Table of ContentsIntroWrap async calls with coroutineScope or use SupervisorJob to handle exceptionsPrefer the Main dispatcher for root coroutineAvoid usage of unnecessary async/awaitAvoid cancelling scope jobAvoid writing suspend function with an implicit dispatcherAvoid usage of global scopeIntroDecided to write about several things which in my opinion you should and shouldn’t do (or at least tr
Lunch Atop a Skyscraper by BalakovSubtle oversights with more or less serious consequences - even if you’re not making these mistakes it should be worth keeping them in mind to avoid running into some problems in future. This article covers: Leaking LiveData observers in FragmentsReloading data after every rotationLeaking ViewModelsExposing LiveData as mutable to ViewsCreating ViewModel’s dependen
“silhouette of trees covered by fogs” by Clément M. on UnsplashAt the heart of Kotlin coroutines is the CoroutineContext interface. All the coroutine builder functions like launch and async have the same first parameter, context: CoroutineContext. These coroutine builders are also all defined as extension functions on the CoroutineScope interface, which has a single abstract read-only property, co
Disclaimer: this is not yet-another-article about build performance. If that’s what you were looking for, go to https://guides.gradle.org/performance/ and https://developer.android.com/studio/build/optimize-your-build Here are some tips I have found useful when working with Gradle in Android Studio. Run unit tests before launching the appSo you made the effort to write unit tests? Good. How useful
Over the years the typical architecture of an Android application has changed a lot, from the first apps where all the logic was in the Activity a lot of different patterns have emerged. Right now MVP and MVVM are probably the most common architectural patterns for the UI (often together with something based on the clean architecture) but there are a lot of alternatives. For example, many develope
Google has recently announced various android libraries to introduce some best practices in the world of android during I/O 2018. One of them is the Navigation Architecture Component. we’ll not be covering the basics of this component as its already available in developer docs and this Codelab. Be sure to read them before going further! When Google announced this component, I jumped straight into
次のページ
このページを最初にブックマークしてみませんか?
『ProAndroidDev』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く