Three Common Problems

  1. Tutorial hell Internet age tutorial is flooding. As a beginner developer, it’s easy to get stuck in the tutorial zone, or “tutorial hell”. A lot of people get stuck there, and stay beginners for way too long. This is where you watch tutorial after tutorial without ever getting your hands dirty. Building projects is not mutually exclusive to the learning phase. You have to constantly iterate between learning and building because learning never actually ends. This is why I emphasized choosing learning resources that feature a lot of code-along projects to get you started practicing. Make sure to code along and not just watch. This helps you get started making something. This book’s 22 cases walk you through more than 50 key knowledge of Android. They are not just telling you what they are, but use the real projects (cases) to show you how to do. One way to get some practice is, at the end of every module, think of features that you can add to the project that you’ve coded. Just try to build something with the new knowledge that you have gained. It doesn’t have to be too fancy. The most important thing is that you write code, run into errors, google how to debug it, and gain more understanding. Practice solidifies knowledge, so practice 1 completed project/case is better than 10 watched tutorials. For project ideas, follow this book’s cases. These 22 projects are key elements of almost every actual commercial app, like Login/Register, Room Database, ListView, Chat Room, just name a few. After you could redo these cases, you will be qualified for an entry level Android App developer. The 22 cases are open-sourced, so you can use them directly in your daily work with minimum modification, which help you go on track fast. Each case is designed by senior mentors and developers to help bridge the learning gap between theory and real-world code. Android

  2. Solution not always working It’s easy to find a solution for a specific problem. But talking about the workable solution, most of developers will shake the head. The main reason is that Android has developed too fast and too loosen. There are 12 big versions and hundreds small ones. Considering the customization from all the handsets manufacturers and third party ROM providers, this number could grow to hundreds. The fragment of Android system is always a hot topic. The consequence? This version’s solution may not work in another. So we spend time in searching the solution, downloading, configuring, and running. The result might be a no-meaning error message. We are beginner. If we could tell the difference, we would not search it. It’s just wasting time. Finally, you find a solution, and implemented into your project. And then, you found a short message “it’s depreciated”. Google will give an guidance, but not solution. Some might ignore it based on some professional’s advice, But in reality we don’t need much time to get some confusing crash due to it. Before Google could fix it, we need a workable examples to guide us through the basic Android skills. We don’t want to waste time on some solutions abandoned or misled. Another one found a great solution (a lib) from Github. Implementing the lib, and your project runs perfectly. Soon, you get a notice from the author, the lib is deprecated, and not maintained anymore. Are you willing to continue with it? This is what we are doing in our cases: use only genuine Android function, even if some third-party could be easier and attractive. We don’t want to spend time learning and loss it sometime later. This is what this book for.
  3. Android official sample too complicated We won’t really know it till we try to implement one function. For example, we want to learn Room Database. The sample will bring you Fragment, RecyclerView, Threading, Threading Pool, MVP, MVC, and Architecture Components. Yes, the sample is a perfect case which implementing the best practice in this topic. But where is my Room knowledge I want to learn? Tell you the truth, they are divided into different parts and sitting in different places following the modern design pattern. It could be a perfect solution for an experienced programmer. But it is a disaster for a beginner. Some might argue all these knowledge are important for the learner. I would say even so, we still need eat it bite by bite. Google forgets an old saying “if you chase two rabbits, you will not catch any”. In our book, however, we extracted the essence of each knowledge, embedded it in a complete workable case, and strengthen the tricks to use them. You will understand the concept in a concise way, and catch the core component easily. Most of our confusion is: the core function needs a lot of related functions to perform well. But when we combine all of them together, we will be confused about the core function. Below is extracted from stackoverflow who has the same headache: I’ve made a list of items a few times using Android’s RecyclerView, but it is a rather complicated process. Going through one of the numerous tutorials online works (this, this, and this are good), but I am looking a bare bones example that I can copy and paste to get up and running quickly. Only the following features are necessary:
    • Vertical layout
    • A single TextView on each row
    • Responds to click events Because I have wished for this several times, I finally decided to make the answer below for my future reference and yours.