Learn Android Studio with Kotlin Efficient Android App Development — Ted Hagos Learn Android Studio with Kotlin Efficient Android App Development Ted Hagos Learn Android Studio with Kotlin: Efficient Android App Development Ted Hagos Manila, National Capital Region, Philippines ISBN-13 (pbk): 978-1-4842-3906-3 https://doi.org/10.1007/978-1-4842-3907-0 ISBN-13 (electronic): 978-1-4842-3907-0 Library of Congress Control Number: 2018962941 Copyright © 2018 by Ted Hagos This work is subject to copyright All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed Trademarked names, logos, and images may appear in this book Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made The publisher makes no warranty, express or implied, with respect to the material contained herein Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Coordinating Editor: Mark Powers Cover designed by eStudioCalamar Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013 Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springersbm.com, or visit www.springeronline.com Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc) SSBM Finance Inc is a Delaware corporation For information on translations, please e-mail rights@apress.com, or visit http://www.apress.com/ rights-permissions Apress titles may be purchased in bulk for academic, corporate, or promotional use eBook versions and licenses are also available for most titles For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book's product page, located at www.apress.com/9781484239063 For more detailed information, please visit http://www.apress.com/source-code Printed on acid-free paper For Adrianne and Stephanie Table of Contents About the Author��������������������������������������������������������������������������������������������������� xiii About the Technical Reviewers�������������������������������������������������������������������������������xv Acknowledgments�������������������������������������������������������������������������������������������������xvii Introduction������������������������������������������������������������������������������������������������������������xix Part I: The Kotlin Language���������������������������������������������������������������������������� Chapter 1: Getting into Kotlin����������������������������������������������������������������������������������� About Kotlin����������������������������������������������������������������������������������������������������������������������������������� Installing the Java SDK����������������������������������������������������������������������������������������������������������������� Installing on macOS����������������������������������������������������������������������������������������������������������������� Installing on Windows 10�������������������������������������������������������������������������������������������������������� Installing on Linux������������������������������������������������������������������������������������������������������������������� Installing Kotlin��������������������������������������������������������������������������������������������������������������������������� 10 Installing the Command Line Tools���������������������������������������������������������������������������������������� 10 Coding With the Command Line Tools����������������������������������������������������������������������������������� 15 Installing IntelliJ�������������������������������������������������������������������������������������������������������������������� 17 Creating a Project����������������������������������������������������������������������������������������������������������������������� 19 The IntelliJ IDE���������������������������������������������������������������������������������������������������������������������������� 29 Chapter Summary����������������������������������������������������������������������������������������������������������������������� 31 Chapter 2: Kotlin Basics����������������������������������������������������������������������������������������� 33 Program Elements���������������������������������������������������������������������������������������������������������������������� 33 Literals����������������������������������������������������������������������������������������������������������������������������������� 34 Variables�������������������������������������������������������������������������������������������������������������������������������� 34 Expressions and Statements������������������������������������������������������������������������������������������������� 36 Keywords������������������������������������������������������������������������������������������������������������������������������� 37 v Table of Contents Whitespace���������������������������������������������������������������������������������������������������������������������������� 38 Operators������������������������������������������������������������������������������������������������������������������������������� 39 Blocks������������������������������������������������������������������������������������������������������������������������������������ 41 Comments����������������������������������������������������������������������������������������������������������������������������� 42 Basic Types��������������������������������������������������������������������������������������������������������������������������������� 44 Numbers and Literal Constants��������������������������������������������������������������������������������������������� 44 Characters����������������������������������������������������������������������������������������������������������������������������� 46 Booleans�������������������������������������������������������������������������������������������������������������������������������� 47 Arrays������������������������������������������������������������������������������������������������������������������������������������ 47 Strings and String Templates������������������������������������������������������������������������������������������������ 49 Controlling Program Flow����������������������������������������������������������������������������������������������������������� 51 Using ifs��������������������������������������������������������������������������������������������������������������������������������� 51 The when Statement������������������������������������������������������������������������������������������������������������� 53 The while Statement������������������������������������������������������������������������������������������������������������� 55 for loops�������������������������������������������������������������������������������������������������������������������������������� 55 Exception Handling��������������������������������������������������������������������������������������������������������������������� 57 Handling Nulls����������������������������������������������������������������������������������������������������������������������������� 58 Chapter Summary����������������������������������������������������������������������������������������������������������������������� 60 Chapter 3: Functions���������������������������������������������������������������������������������������������� 63 Declaring Functions�������������������������������������������������������������������������������������������������������������������� 63 Single Expression Functions������������������������������������������������������������������������������������������������� 67 Default Arguments���������������������������������������������������������������������������������������������������������������������� 68 Named Parameters��������������������������������������������������������������������������������������������������������������������� 69 Variable Number of Arguments��������������������������������������������������������������������������������������������������� 70 Extension Functions�������������������������������������������������������������������������������������������������������������������� 71 Infix Functions����������������������������������������������������������������������������������������������������������������������������� 73 Operator Overloading������������������������������������������������������������������������������������������������������������������ 75 Chapter Summary����������������������������������������������������������������������������������������������������������������������� 78 vi Table of Contents Chapter 4: Working with Types������������������������������������������������������������������������������� 79 Interfaces������������������������������������������������������������������������������������������������������������������������������������ 79 Diamond Problem������������������������������������������������������������������������������������������������������������������ 81 Invoking Super Behavior������������������������������������������������������������������������������������������������������� 82 Classes���������������������������������������������������������������������������������������������������������������������������������������� 84 Constructors�������������������������������������������������������������������������������������������������������������������������� 85 Inheritance���������������������������������������������������������������������������������������������������������������������������� 88 Properties������������������������������������������������������������������������������������������������������������������������������ 92 Data Classes������������������������������������������������������������������������������������������������������������������������������� 96 Visibility Modifiers��������������������������������������������������������������������������������������������������������������������� 100 Access Modifiers����������������������������������������������������������������������������������������������������������������������� 102 Object Declarations������������������������������������������������������������������������������������������������������������������� 102 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 103 Chapter 5: Lambdas and Higher Order Functions������������������������������������������������� 105 Higher Order Functions������������������������������������������������������������������������������������������������������������� 105 Lambda and Anonymous Functions������������������������������������������������������������������������������������������ 109 Parameters in Lambda Expressions������������������������������������������������������������������������������������ 110 Closures������������������������������������������������������������������������������������������������������������������������������� 113 with and apply�������������������������������������������������������������������������������������������������������������������������� 114 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 116 Chapter 6: Collections and Arrays������������������������������������������������������������������������ 117 Arrays���������������������������������������������������������������������������������������������������������������������������������������� 117 Collections�������������������������������������������������������������������������������������������������������������������������������� 121 Lists������������������������������������������������������������������������������������������������������������������������������������� 123 Sets������������������������������������������������������������������������������������������������������������������������������������� 124 Maps������������������������������������������������������������������������������������������������������������������������������������ 125 Collections Traversal������������������������������������������������������������������������������������������������������������ 127 Filter and Map��������������������������������������������������������������������������������������������������������������������������� 128 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 130 vii Table of Contents Chapter 7: Generics���������������������������������������������������������������������������������������������� 133 Why Generics���������������������������������������������������������������������������������������������������������������������������� 133 Terminologies���������������������������������������������������������������������������������������������������������������������������� 135 Using Generics in Functions����������������������������������������������������������������������������������������������������� 136 Using Generics in Classes��������������������������������������������������������������������������������������������������������� 138 Variance������������������������������������������������������������������������������������������������������������������������������������ 140 Subclass vs Subtype����������������������������������������������������������������������������������������������������������������� 144 Reified Generics������������������������������������������������������������������������������������������������������������������������ 149 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 153 Part II: Android Programming with Kotlin�������������������������������������������������� 155 Chapter 8: Android Studio Introduction and Setup����������������������������������������������� 157 History��������������������������������������������������������������������������������������������������������������������������������������� 157 Architecture������������������������������������������������������������������������������������������������������������������������������ 158 Android Studio IDE�������������������������������������������������������������������������������������������������������������������� 160 Setup����������������������������������������������������������������������������������������������������������������������������������������� 161 Android Studio Configuration���������������������������������������������������������������������������������������������������� 163 Hardware Acceleration�������������������������������������������������������������������������������������������������������������� 169 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 170 Chapter 9: Getting Started������������������������������������������������������������������������������������ 173 What’s in an App����������������������������������������������������������������������������������������������������������������������� 173 Component Activation���������������������������������������������������������������������������������������������������������� 176 Creating a Project��������������������������������������������������������������������������������������������������������������������� 177 The IDE�������������������������������������������������������������������������������������������������������������������������������������� 190 Main Menu��������������������������������������������������������������������������������������������������������������������������� 192 Keyboard Shortcuts������������������������������������������������������������������������������������������������������������� 193 Customizing Code Style������������������������������������������������������������������������������������������������������� 195 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 196 viii Table of Contents Chapter 10: Activities and Layouts����������������������������������������������������������������������� 197 Application Entry Point�������������������������������������������������������������������������������������������������������������� 197 Activity Class����������������������������������������������������������������������������������������������������������������������� 198 Layout File��������������������������������������������������������������������������������������������������������������������������� 200 View and ViewGroup Objects����������������������������������������������������������������������������������������������� 201 Containers��������������������������������������������������������������������������������������������������������������������������� 203 Hello World�������������������������������������������������������������������������������������������������������������������������������� 204 Modifying Hello World���������������������������������������������������������������������������������������������������������� 208 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 218 Chapter 11: Event Handling���������������������������������������������������������������������������������� 221 Introduction to Event Handling�������������������������������������������������������������������������������������������������� 221 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 237 Chapter 12: Intents����������������������������������������������������������������������������������������������� 239 What Intents Are������������������������������������������������������������������������������������������������������������������������ 239 Loose Coupling�������������������������������������������������������������������������������������������������������������������������� 242 Two Kinds of Intent������������������������������������������������������������������������������������������������������������������� 243 Intents Can Carry Data�������������������������������������������������������������������������������������������������������������� 243 Getting Back Results from Another Activity������������������������������������������������������������������������� 246 Implicit Intents�������������������������������������������������������������������������������������������������������������������������� 249 Demo 1: Launch an Activity������������������������������������������������������������������������������������������������������� 251 Demo 2: Send Data to an Activity���������������������������������������������������������������������������������������������� 259 Demo 3: Send and Get Data Back to and from an Activity������������������������������������������������������� 265 Demo 4: Implicit Intents������������������������������������������������������������������������������������������������������������ 278 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 282 Chapter 13: Themes and Menus��������������������������������������������������������������������������� 283 Styles and Themes�������������������������������������������������������������������������������������������������������������������� 283 Customizing the Theme������������������������������������������������������������������������������������������������������� 286 Menus��������������������������������������������������������������������������������������������������������������������������������������� 288 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 303 ix Table of Contents Chapter 14: Fragments����������������������������������������������������������������������������������������� 305 Introduction to Fragments��������������������������������������������������������������������������������������������������������� 305 Book Title and Description, a Fragments Demo������������������������������������������������������������������������ 311 Fragments Demo, Dynamic������������������������������������������������������������������������������������������������������� 337 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 341 Chapter 15: Running in the Background�������������������������������������������������������������� 343 Basic Concepts������������������������������������������������������������������������������������������������������������������������� 344 The UI Thread���������������������������������������������������������������������������������������������������������������������������� 344 Threads and Runnables������������������������������������������������������������������������������������������������������������ 349 Using the Handler Class������������������������������������������������������������������������������������������������������������ 354 AsyncTask��������������������������������������������������������������������������������������������������������������������������������� 357 Anko’s doAsync������������������������������������������������������������������������������������������������������������������������� 360 A Real-World Example�������������������������������������������������������������������������������������������������������������� 363 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 371 Chapter 16: Debugging����������������������������������������������������������������������������������������� 373 Syntax Errors���������������������������������������������������������������������������������������������������������������������������� 373 Runtime Errors�������������������������������������������������������������������������������������������������������������������������� 377 Logic Errors������������������������������������������������������������������������������������������������������������������������������� 382 Walking Through Code��������������������������������������������������������������������������������������������������������� 385 Other Notes������������������������������������������������������������������������������������������������������������������������������� 387 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 388 Chapter 17: SharedPreferences���������������������������������������������������������������������������� 389 Sharing Data Between Activities����������������������������������������������������������������������������������������������� 398 Chapter Summary��������������������������������������������������������������������������������������������������������������������� 406 Chapter 18: Internal Storage�������������������������������������������������������������������������������� 407 Overview of File Storage����������������������������������������������������������������������������������������������������������� 407 Internal and External Storage���������������������������������������������������������������������������������������������� 408 Cache Directory������������������������������������������������������������������������������������������������������������������� 409 x Chapter 20 App Distribution Click Google Play, as shown in Figure 20-7 Figure 20-7. developer.android.com Click Launch Play Console, as shown in Figure 20-8 Figure 20-8. Launch Play Console 454 Chapter 20 App Distribution Figure 20-9. Google Play console, sign up You need to go through four steps to complete the registration (shown in Figure 20-9): Sign-in with your Google account Accept the developer agreement Pay the registration fee Complete your account details Once you have completed the registration and payment, you will now have access to the Google Play console, as shown in Figure 20-10 455 Chapter 20 App Distribution Figure 20-10. Play Console This is where you can start the process of submitting your app to the store Click the “Create application” button to get started Chapter Summary 456 • Your codes may be great, but the user will never see them Pay attention (also) to the things the user will see, like icons and other graphical assets • Clean up your code before you release them Remove all those log and debug info • Code-review your own work If you have buddies or other people who can review the code with you, that’s much better If your app uses servers, RESTful URLs, etc., make sure they are production-ready and not sandboxes • You can’t use debug certificates if you want to release your app into marketplaces like Google Play or Amazon Chapter 20 App Distribution • You’ll need a Google Play account if want to sell your apps on Google Play I paid a one-time fee of $25 USD, but that was a couple of years ago • Don’t forget to test your app on a real device • We tried to distill and simplify the process of putting your app in the Play Store,\ but this chapter isn’t a subsitute to Android Developer’s launch checklist You should still read that You can find at https:// bit.ly/appstorelaunchchecklist 457 Index A Access modifiers, 102 Accessor methods, 94–96 ADTs, see Android development tools (ADTs) Android architecture of, 158–160 history, 157–158 Studio (see Android Studio) Android app AndroidManifest, 175–176 AS3 IDE (see AS3 IDE) components activities, 174 BroadcastReceivers, 174–175 Contacts app, 176 ContentProviders, 174–175 Intents, 176–177 Services, 174–175 EXE files, 173 logical structure, APK, 173 project creation AS3 welcome screen, 177–178 AVDs, 183, 188, 190 choosing activity, 181 Component installer, 186 configure activity, 182 “Include Kotlin support” tick box, 179 Instant apps, 180 Instant run, 189 launching AS3, 177 location, 178 main AS3, 182–183 new project, 178 package name, 178 Run icon, 183 Select Deployment Target screen, 183, 189 selecting hardware, 184 system image, 185, 187 target Android devices, 179 Android Debug Bridge (adb), 387, 439 Android development tools (ADTs), 160 Android Device Monitor, 387 Android Honeycomb, 289 Android Not Responding (ANR), 348 Android Studio in 2013, 161 ADTs, 160 AS3 installer, 161 AVD, 169 32-bit libraries, Linux, 162 commercial Java IDE, 161 configuration API levels, 165 changes, channel, 168 coding, 163 SDK tools, 166–167 SDK window, 165 updates, 167–168 © Ted Hagos 2018 T Hagos, Learn Android Studio with Kotlin, https://doi.org/10.1007/978-1-4842-3907-0 459 Index Android Studio (cont.) HAXM, Windows users, 169 IDE, 160, 171 JDK, 161 JVM languages, 161 KVM, Linux users, 169 Linux installation, 162 macOS, 161 macOS users, 169 SDK manager, 160 Window, 162 Android Studio (AS3), 17 IntelliJ IDEA (see IntelliJ IDEA) Android Virtual Devices (AVDs), 169, 183, 188, 190 App configuration cloud services, 448 debugging information, 447 log issue, 447 package name, 447 permissions, 447 ProGuard, 447 web APIs, 448 App distribution Android apps, 445 developer.android.com, 445 Google Play Store, 446 publishing App, 445 release preparation app’s icon, 446 configuration (see App configuration) Google marketplace, 446 graphical assets, 446 release-ready application (see Release-ready application) releasing App developer account, 452 developer.android.com, 453–454 460 Google account, 453 Google Play, 452, 454–456 payment, 455 registration, 455 Application entry point Activity Class Kotlin, 198 life cycle, 199 containers, layout managers, 204 layout file, 200–201 manifest file, 197 View, ViewGroup objects, 202–203 Arrays arrayOf function, 119 arrayOfNulls function, 118 constructor, 119 emptyArray function, 118 forEachIndexed function, 120 get function, 118 limitations, 120–121 set function, 118 specialized classes, 119–120 strings, 117 traversing arrays, 120 AS3 IDE customizing code style, 195–196 Editor window, 191 keyboard shortcuts keymap settings, 194–195 list, 193–194 main menu, 192–193 Navigation bar, 192 opened project, 190–191 Project Files, 191 Status Bar, 192 Tool bar, 192 Tool window bar, 192 Tool windows, 192 Index B Backround app Anko’s doAsync build.gradle, 360–361 code, 362 AsyncTask code, MainActivity, 359–360 doInBackground method, 357–358 params, 358 progress, 358 publishProgress method, 358 result, 358 subclass, 357–358 type parameters, 360 handler class code, 355–356 handler object, 354 putString() method, 356 process, 344 threads and runnables, 344 activity_main.xml, 349–350 basic UI, 349 code, 351–353 creation, 351 Logcat window, 350 runOnUiThread method, 353–354 single abstract method, 352 UI thread ANR error, 348 blocked state, 345 cheap call, 345 GCF, 345–346 GitHub, expensive call, 347 killSomeTime function, 347 nested calculation, expensive call, 348 NetworkOnMainThread Exception, 346 steps, 344 Thread.sleep call, 347 BroadcastReceivers Android (API 28), 432 Application’s context, 431 broadcast action, 430 BROADCAST_ACTIONS.TXT file, 427 class creation, 431 CONNECTIVITY_ACTION, 433 custom broadcast App, 427 activity_main.xml, 434 adb, 439 Android SDK, 439–440 BroadcastReceiver, 435 context menu, 435 details, 433 lateinit keyword, 438 MainActivity.java, 437 MainActivity’s UI, 434 MyReceiver.java, 436 onCreate callback, 436 onReceive method, 436 onResume callback, 436 platform-tools, 440 exceptions, 432 execution limits, 432 implicit vs explicit broadcast actions, 432–433 Intents, 425 LocalBroadcastManager class, 444 manifest vs context registration AndroidManifest.xml, 427–428 context register, 429 IllegalArgumentException, 430 intentfilter, 428, 430 MyReceiver class, 428 registerReceiver method, 430–431 461 Index BroadcastReceivers (cont.) onReceive method, 431 publish-subscribe model, 426 register, 431 system broadcast App, 426 ACTION_TIME_TICK, 440–441 vs custom broadcast, 426–427 intentfilter, 443 MainActivity, 442 onResume callback, 441 paused state, 443 project details, 441 TIME_TICK, 432 user interaction, 426 C Classes basic class, 84 constructor, 85–88 custom accessor methods, 95–96 header, 85 inheritance, 89–92 single property, 92–94 Collections, container, 117 Collections framework common operations on, 126–127 data structure, 121 filter and map, 128–130 forEach function, 128 hierarchy of, 122 Iterable interface, 127 library functions, 122–123 lists, 123–124 maps, 125–126 sets, 124–125 while loops, 127 462 Color current colors.xml, 285 defined, 285 Command line tools hello.kt, 16 installing HomeBrew/MacPort, 10–11 SDKMAN, 14 zipped installer (see Zipped installer) REPL, 15–16 Constructor, 85–88 D Data classes, 96–99 Data storage content providers, 390 internal or external storage, 389 network storage, 390 SharedPreferences, 389 SQLite database, 390 Debugging logic errors breakpoints, 385–386 Logcat tool window, 383, 385 runtime errors ArithmeticException, 379, 382 code for opening a file, 378 examples, 378 exception handling, 380 try-catch block, 380–381 syntax errors AsyncTask class, 374–375 code with error, 377 nested blocks, 376 Diamond problem, 81–82 displayMessage() function, 65 Don’t repeat yourself (DRY) principle, 423 Index E End of file (EOF), 411 Event handling activity_main.xml, 228–230 Android framework, 221 annotated code, registering handlers, 223 AS3 hints, 231–232 build.gradle file, 234 button control, design surface, 226 convert to lambda hint, 232 convert to lambda quick fix, 232 event objects, 221 Extract Resource, 227–228 id attribute of layout container, 229 KAE, 231 listener objects, 221, 223 MainActivity.Kt, 230, 235 OnClickListener, 224, 231 OnLongClickListener, 233 project information, 225 project running, emulator, 236–237 setOnClickListener, 224 simplified model, 222 SnackBar, OnLongClickListener, 235 suggested fix, 227 text property, 227 Toast message, 233 user’s action, 222 View.OnClickListener Lava, 224 Kotlin, 225 lambdas, 225 warnings and error button, 226 Exception handling, 57–58 Extension functions chanthofy, 71 homerify, 71–73 String class, 72–73 StringUtil class, 71–72 terminatorify, 71 F File storage cache directory, 409 external storage, 408 internal storage, 408 Java file I/O, 407 for loops statement, 55–56 Fragments activity_main, element, 309–310 BookTitle, 308 book title and description, demo activity_main.xml, 322 BookDescription class, 319–320, 335, 337 book_description fragments, 323–324 book_description.xml, 314–315, 319 BookTitle class, 316–318 BookTitle, code, 332–333 book_titles fragments, 323–324 book_titles.xml, 315–316 callbacks, 335 changeDescription function, 328 communication, 328 coordinator interface, 328–330 device orientation, 334 emulator, 333–334 horizontal orientation, 312, 324 inflate method, 318 Kotlin file/class, 329 layout-land, 326–327 layout resource file, 326 linearLayout, 321–322 MainActivity, 320–321, 331–332 onBookChanged method, 331 463 Index Fragments (cont.) onCreateView method, 318 onSaveInstanceState method, 335–336 project details, 312–313 project view, 324–325 radiobutton, 332 resource directory, 325 synchronization, 327 vertical orientation, 311 view.id, 318 XML values file, 313–314 creation, 306 defined, 306 dynamic demo activity_main.xml, 338–339 beginTransaction() method, 341 commit() method, 341 FragmentManager, 337 FragmentTransaction object, 337 getSupportFragmentManager() method, 341 MainActivity, 339–341 onBookChanged() method, 341 project, changes, 338 project details, 337 FragmentsTest, 310 Kotlin class, 307–308 onCreateView method, 309 resource file, 306–307 XML file, 306 Functional language, Functions declaration, 63 displayMessage, 64–65 getSum, a productive function, 66–67 using pairs, 66–67 464 default arguments, connectToDb, 68 infix, 73–75 named parameters, 69 operator overloading, 75–78 variable number of arguments, vararg function, 70 G Generic programming class, 138–140 extension function, 137–138 fooBar function, 136–137 Java, 133–134 parametric polymorphism, 135–136 reified function, 149, 151–153 variance class, 144–145 contravariance, 143–144 generics type, 146–147 list interface, 148 LSP, 141–142 nullable types, 145 OOP, 140 open closed principle, 141 GitHub API activity_main.xml, 366–367 AndroidManifest.xml, 370–371 GetGitHubInfo, 365 JSON response, 363–364 MainActivity, 369–370 OkHttp, 367–369 project details, 365 H Hello world application attributes window, 214 clear constraints, 212 Index design view, 209 inferred constraints, 213 MainActivity class, 215–217 MainActivity files, 207 manifest file, 206 modification, 208 project information, 205 project view, 207 running on an emulator, 217 view palette, 210 Higher order functions action, type String, 106 declare and define, 107 description, 105 doThis and executor(), 107–109 function type, 106 parameter, 106 Hype cycle, I if statement, 51, 53 Inheritance, 89–92 IntelliJ IDEA creating project Hello.kt, 24–29 Kotlin/JVM, 20 kotlinproject, 20–21 Project Tool window, 22–23 tip of the day, 21–22 welcome screen, 19 download page, 17 IDE, 29–30 Linux, 18 macOS, 18 Windows, 18 Intents Android app, 239–240 defined, 239 explicit, 243 getApplicationContext(), 241 getExtra method, 244, 246 getIntent() function, 246 implicit, 243, 249 MainActivity, 279–281 project details, 278 snapshots, 282 launching activity activity_main.xml, 253–254 activity_second.xml, 254 button view, 252–253 logcat tool window, 258 MainActivity.Kt, 255–256 project detail, 251 project tool window, 251 SecondActivity.Kt, 256–257 loose coupling, 242–243 MainActivity, 243–244 onActivityResult, 247–248 onCreate method, 244, 246 putExtra method, 243, 245–246 SecondActivity, 243, 252 send and get data, project activity_main.xml, 268–269 activity_second.xml, 270–272 EditText views, 266–267 empty activity, creation, 269 finish() method, 273 gerBMIDescriptionfunction, 278 getStringExtra method, 264 layout, 266 MainActivity, oncreate method, 272–273 project details, 265 SecondActivity, creation, 269–270 setResult method, 274 465 Index Intents (cont.) send data, project activity_main.xml, 259–260 activity_second.xml, 260, 262 MainActivity, 263, 275–278 project details, 259 SecondActivity, 264 sequence diagram, 247, 257–258 setResult method, 246 startActivityForResult method, 246–247 startActivity method, 244 this@MainActivity, 241 web browser, launching, 249–250 Interfaces basic form, 79–80 default implementations, 80 diamond problem, 81–82 MultiFunction class, 80 super keyword, 82–84 Internal storage activity_main.xml, 414–415 activity_second.xml, 415 context mode, 410 DRY principle, 423 EOF marker, 411 exception handling, 418, 423 explicit Intent, 412–413 getCacheDir(), 409 housekeeping codes, 417 loadData function, 416–417 MainActivity, 419, 421 MODE_PRIVATE, 410 multiline EditText, 412–413 onPause method, 418 onResume callback, 416 openFileInput(), 409 openFileOutput(), 409 project details, 412 466 read file, 410–411 read method, 411 runOnUiThread, 417 saveData function, 418–419, 422 save file, 410 SecondActivity, 422–423 start method, 418 TextView object, 423 threading, 423 try-catch block, 417 UI thread, 419 use extension, 410 write method, 410 writing file, 409 Iterable interface, 127 J Java interoperability with, methods, 63 OOP, type erasure, 149 Java SDK, install Linux, macOS, Oracle JDK download page, Windows 10, Java Virtual Machine (JVM), JetBrains, K Kernel-based Virtual Machine (KVM), 169 Kotlin type inference, 35 types arrays, 47–48 Index Booleans, 47 characters, 46 literal constant, 45 numbers, 44 strings, 49–50 template, 50–51 Kotlin Android Extension (KAE), 231, 236 L Lambdas and anonymous functions closures, 113 doThis, 109 higher order function, 109–110 parameters, 110–113 with and apply, 114–116 Liskov Substitution Principle (LSP), 141–142 Lubuntu 3, 17 M Menus with ActionBar, 290 add to an app, 290–291 Android Honeycomb, 289 creating Demo App Android Resource Directory, 293 attributes, 295 build.gradle file, 292–293, 302 CHAppBar menus, 297 MainActivity codes, 299–301 onCreateOptionsMenu, 297 project details, 291 resource file, 294 inflate()function, 297 on older Android hardware, 289 N Nullable types, 59–60 Null value, handling, 58–60 O Object declarations, 102–103 Open closed principle, 141 Operator overloading class employee, 75–76 employee objects, 75 function names, 77 polymorphism, 77 P, Q Parametric polymorphism, 135–136 Preferences, AS3 opening screen, 164 Program elements blocks, 41–42 comments, 42–43 expressions and statements, 36–37 keywords, 37 literals, 34 operators and symbols, 39–41 variables, 34–35 whitespace, 38 Program flow, control for loops statement, 55–56 if statement, 51, 53 when statement, 53–55 while statement, 55 Project, see GitHub API R Read, Eval, Print, Loop (REPL), 15 Reified generics, 149, 151–153 467 Index Release-ready application Android Studio, 448 APK, 448 Build type, 452 debug certificate, 448 JKS file, 451 keystore dialog, 449 Keystore items, 451 Key store path, 449 signed APK, 449, 451–452 S Safe call operator, 59–60 SDKMAN, 14 SharedPreferences Activities, sharing data activity_main.xml, 401–402 activity_second.xml, 402–403 application level preferences file, 398 clear()function, 406 getPreferences function, 399 getSharedPreferences function, 399 getString method, 399 MainActivity, 403–404 onPause function, 404 onResume function, 405 project details, 399 remove function, 406 saveData function, 404 SecondActivity, 405–406 SharedPreferences.Editor, 406 storyboard, 400 device file explorer, 396–397 getPreferences method, 390 468 key-value pairs, 390 MainActivity class, 395–396, 398 MainActivity.xml file, 397–398 MODE_APPEND, 392 MODE_PRIVATE, 391 MODE_WORLD_READABLE, 391 MODE_WORLD_WRITEABLE, 392 project details, 392 putString, 391 save data, 391 SharedPreferences.editor, 396 TextView object, 392 XML layout file, 393–395 Single Abstract Method (SAM), 352 Single expression functions, 67–68 Single property, 92–94 SOLID design principles, 141 startActivity() function, 241 Style current styles.xml, 284 definition, 283 Super keyword, 82–84 T, U Theme customizing color picker, 287 palette, 288 Theme editor, 286 Traversing arrays, 120 Type erasure, 149 V Visibility modifiers, 100–102 Index W, X, Y Z when statement, 53–55 while statement, 55 Windows 4, 8–10, 14 Zipped installer GitHub releases, 11–12 unzip command, 12–13 Windows 10, 14 469 .. .Learn Android Studio with Kotlin Efficient Android App Development Ted Hagos Learn Android Studio with Kotlin: Efficient Android App Development Ted Hagos Manila,... still, the chapters are short • Multiple Learning Curves The book is about three topics: Android Studio, Android Programming, and Kotlin Although Kotlin and Android programming may seem to have dedicated... www.apress.com/9781484 239 0 63 xxiv PART I The Kotlin Language CHAPTER Getting into Kotlin What we’ll cover: • An introduction to the Kotlin language • How to get Kotlin • Installing Kotlin on macOS,