Android Application Development All-in-One For Dummies (3rd Edition)

Rs. 11,180
  • Author: B Burd
  • ISBN: 9781119660453
  • Publisher: Wiley Publishing
  • Edition: 3rd
  • Publication Date: September 21, 2020
  • Format: Paperback – 800 pages
  • Language: English

Out of stock

SKU 9781119660453 Category Tag

Share
Description

Conquer the world of Android app development

Android has taken over the mobile and TV markets and become unstoppable! Android offers a vast stage for developers to serve millions—and rake in the profits—with diverse and wide-ranging app ideas. Whether you’re a raw recruit or a veteran programmer, you can get in on the action and become a master of the Android programming universe with the new edition of Android Application Development For Dummies All-in-One. In addition to receiving guidance on mobile and TV development, you’ll find overviews of native code, watch, car, Android wear, and other device development.

This friendly, easy-to-follow book kicks off by offering a fundamental understanding of Android’s major technical ideas, including functional programming techniques. It moves on to show you how to work effectively in Studio, program cool new features, and test your app to make sure it’s ready to release to a waiting world. You’ll also have an opportunity to brush up on your Kotlin and develop your marketing savvy. There are millions of potential customers out there, and you want to stand out from the crowd!

  • Understand new features and enhancements
  • Get development best-practices
  • Know your Android hardware
  • Access online materials

With a market share like Android’s, the stakes couldn’t be higher. Android Application Development For Dummies All-in-One levels the field and gives you the tools you need to take on the world.

Table of Contents
  1. Introduction 1
    1. How to Use This Book 1
    2. Conventions Used in This Book 2
    3. Foolish Assumptions 2
    4. Icons Used in This Book 3
    5. Beyond the Book 4
    6. Where to Go from Here 4
  2. Book 1: Getting Started with Android Application Development 5
  3. Chapter 1: All about Android 7
    1. The Consumer Perspective 8
    2. The Versions of Android 9
    3. The Developer Perspective 12
    4. Java and Kotlin 12
    5. XML 14
    6. Linux 16
    7. The Business Perspective 18
  4. Chapter 2: Installing the Software Tools 19
    1. Setting Up the Software 20
    2. Considering the requirements 20
    3. Downloading the software 21
    4. Installing Android Studio 23
    5. Installing offline tools 25
    6. Launching the Android Studio IDE 28
    7. In Windows 29
    8. On a Mac 29
    9. In Linux 30
    10. In Chrome OS 30
    11. Using the Android Studio Setup Wizard 30
    12. Fattening Up the Android SDK 32
    13. The more things stay the same, the more they change 32
    14. Installing new versions (and older versions) of Android 33
    15. Creating an Android virtual device 35
    16. A third-party emulator 39
  5. Chapter 3: Creating an Android App 43
    1. Creating Your First App 43
    2. Starting the IDE and creating your first app 45
    3. Launching your first app 50
    4. Running Your App 52
    5. You Can Download All the Code 55
    6. Troubleshooting Common IDE Errors 58
    7. Error message: Failed to find target 58
    8. Error running ‘app’: No target device found 58
    9. Error message: Android Virtual Device may be incompatible with your configuration 58
    10. You lose contact with the Android Debug Bridge (ADB) 59
    11. You don’t like whatever AVD opens automatically 59
    12. The emulator stalls during startup 60
    13. Error message: The user data image is used by another emulator 61
    14. Error message: Unknown virtual device name 63
    15. The emulator displays a “process isn’t responding” dialog box 63
    16. Changes to your app don’t appear in the emulator 64
    17. Testing Apps on a Real Device 64
  6. Chapter 4: Examining a Basic Android App 67
    1. A Project’s Files 68
    2. The MainActivity.kt file 71
    3. The onCreate() method 72
    4. Using other templates 73
    5. The res Branch 76
    6. The res/drawable branch 77
    7. The res/layout branch 77
    8. The res/menu branch 78
    9. The res/mipmap branch 79
    10. The res/values branch 80
    11. Other Files in an Android Project 82
    12. The build.gradle file 82
    13. The AndroidManifest.xml file 85
    14. The R.java file 87
    15. The assets folder 89
    16. The android.jar archive 90
    17. The APK file 91
    18. What Did I Agree To? 93
    19. What’s in a name? 93
    20. Choosing a language 95
    21. Your app’s API levels 95
  7. Chapter 5: Conjuring and Embellishing an Android App 101
    1. Dragging, Dropping, and Otherwise Tweaking an App 102
    2. Creating the “look” 102
    3. Coding the behavior 112
    4. A Bit of Debugging 118
    5. Try it! 118
    6. Discovering the secrets of Logcat 123
    7. Using the debugger 126
  8. Chapter 6: Improving Your App 131
    1. Improving the Layout 131
    2. Changing the layout 132
    3. Creating a reusable layout 139
    4. Reusing a layout 142
    5. Starting Another Activity 145
    6. Localizing Your App 151
    7. Responding to Check Box Events 155
    8. Displaying Images 157
    9. Sending in Your Order 162
  9. Book 2: Android Background Material 167
  10. Chapter 1: Using Android Studio 169
    1. Good to Know versus Need to Know 170
    2. Getting a Feel for the Big Picture 171
    3. The main window 173
    4. Viewing modes 179
    5. The Designer tool 181
    6. Discovering What You Can Do 184
    7. Finding things 185
    8. Fixing code 190
    9. Refactoring 199
  11. Chapter 2: Kotlin for Java Programmers 203
    1. Using Kotlin or Java for Development 204
    2. Defining the Java Issues That Kotlin Fixes 207
    3. Improving control over null references 207
    4. Removing raw data types 210
    5. Using invariant arrays 210
    6. Working with proper function types 212
    7. Getting rid of the checked exceptions 213
    8. Nothing’s Perfect: Kotlin is Missing Features, Too 214
    9. Considering primitive types that are not classes 214
    10. Losing static members 214
    11. Eliminating non-private fields 215
    12. Reducing confusion by eliminating wildcard-types 216
    13. Abandoning the ternary-operator a ? b : c 217
    14. Looking at What Kotlin Adds to the Picture 218
    15. Considering higher order functions and lambdas 218
    16. Refining object orientation using extension functions 218
    17. Relying on smart casts 219
    18. Employing string templates 220
    19. Understanding primary constructors 221
    20. Implementing first-class delegation 221
    21. Using ranges of values 223
    22. Creating data classes 224
    23. Overloading operators 224
    24. Developing asynchronous code using coroutines 225
  12. Chapter 3: Kotlin for Everyone 227
    1. Moving from Development to Execution with Kotlin 228
    2. What is a compiler? 228
    3. Understanding native code compiler or interpreter issues 230
    4. Considering the Android Runtime (ART) 231
    5. Grasping Kotlin Code 235
    6. Nearly everything begins with an expression 236
    7. The Kotlin class 238
    8. Classes and objects 239
    9. Kotlin types 240
    10. Performing casts 245
    11. The Kotlin function 249
    12. Objects and their constructors 252
    13. Classes grow on trees 254
    14. The Kotlin package 255
    15. Considering Kotlin visibility rules 257
    16. Defying your parent 258
    17. Kotlin comments 259
  13. Chapter 4: What Kotlin Does (and When) 261
    1. Making Decisions (Kotlin if Statements) 261
    2. Testing for equality 264
    3. Choosing among many alternatives (Kotlin when statements) 266
    4. Repeating Instructions Over and Over Again 269
    5. Kotlin while statements 269
    6. Kotlin do statements 271
    7. Arrays in Kotlin 273
    8. Kotlin’s for statements 277
    9. Looping using Kotlin recursion 281
    10. Working with break and continue 283
    11. Jumping Away from Trouble 284
    12. Working with Kotlin Collections 286
    13. Considering the collection types 287
    14. Differentiating between read-only and mutable collections 289
  14. Chapter 5: Object-Oriented Programming in Kotlin 291
    1. Static Fields and Methods 291
    2. Interfaces and Callbacks 294
    3. Event handling and callbacks 299
    4. An object remembers who created it 302
    5. A less wordy way to implement an interface 303
    6. Classes That Must (and Must Not) Be Extended 305
    7. The need to override 306
    8. Java’s final classes 306
    9. Kotlin’s open classes 307
    10. Kotlin extensions 307
    11. Abstract classes 308
    12. Inner Classes 310
    13. Named inner classes 310
    14. Anonymous inner classes 312
  15. Chapter 6: Functional Programming in Kotlin 315
    1. Defining Functional Programming 316
    2. Differences from other programming paradigms 316
    3. Understanding its goals 317
    4. Understanding Pure and Impure Languages 318
    5. Using the pure approach 318
    6. Using the impure approach 320
    7. Comparing the Functional Paradigm 320
    8. Using Kotlin for Functional Programming Needs 322
    9. Defining the Role of State 323
    10. Using Recursion to Perform Calculations 324
    11. Relying on standard recursion 324
    12. Relying on tail recursion 326
    13. Using Function Types 327
    14. Understanding Function Literals 329
    15. Lambda expressions 329
    16. Anonymous functions 330
    17. Defining the Function Types 331
    18. Comprehensions 331
    19. Receivers 332
    20. Inline 334
    21. Utility 335
    22. Using Functional Programming for Android Apps 336
  16. Chapter 7: A Look at XML 339
    1. XML Isn’t Ordinary Text 340
    2. Of tags and elements 340
    3. Other things you find in an XML document 348
    4. What’s in a Namespace? 350
    5. The package attribute 353
    6. The style attribute 354
  17. Book 3: The Building Blocks 357
  18. Chapter 1: Getting an Overview of Jetpack 359
    1. Understanding the Benefits of Jetpack 360
    2. Eliminating boilerplate code 360
    3. Managing background tasks 361
    4. Navigating between activities and fragments 362
    5. Managing memory 364
    6. Performing configuration changes 365
    7. Considering the Jetpack Components 366
    8. Foundation 367
    9. Architecture 368
    10. Behavior 370
    11. UI 372
    12. Getting an Overview of the AndroidX Package 373
    13. Working with Lifecycle-Aware Components 374
    14. Focusing on activities 375
    15. Understanding events and states 376
  19. Chapter 2: Building a Foundation for Your App 377
    1. Working with Android KTX 378
    2. Getting a feel for KTX features 378
    3. Using KTX in your project 381
    4. Considering the modules 382
    5. Addressing Security Issues 389
    6. Benchmarking Your Application 392
    7. Removing barriers to correct results 393
    8. Creating a test app 394
    9. Profiling your app 397
    10. Tracing your app 398
    11. Checking for benchmarking module support 400
    12. Benchmarking the app 401
    13. Testing Application Functionality 403
  20. Chapter 3: Creating an Architecture 405
    1. Managing Application Activities 405
    2. Defining an activity 406
    3. Getting an overview of intent filters 407
    4. Considering the activity lifecycle 407
    5. Understanding the backstack 409
    6. Working with fragments 412
    7. Considering the fragment lifecycle 416
    8. Seeing activities and fragments in action 417
    9. Providing for Navigational Needs 433
    10. Creating the navigational graph 434
    11. Adding a NavHostFragment to your activity 437
    12. Adding destinations 438
    13. Creating links between destinations 440
    14. Creating the required linkages 442
    15. Performing Background Tasks Using WorkManager 446
  21. Chapter 4: Defining an App’s Behavior 451
    1. Working with Notifications 452
    2. Understanding what notifications do 452
    3. Anatomy of a notification 454
    4. Assigning a channel to your notification 456
    5. Setting the notification importance 457
    6. Considering the notification types 458
    7. Relying on notification updates 459
    8. Do Not Disturb mode 460
    9. Creating a notification 460
    10. Getting Permission 466
    11. Considering permission use 467
    12. Configuring permissions in AndroidManifest.xml 468
    13. Complying with User Preferences 469
    14. Deciding on a preference set 470
    15. Setting preferences using the Preference Library 472
    16. Working with MediaPlayer 481
    17. Adding Camera Support Using CameraX 484
    18. Sharing with Others 487
    19. Performing simple share actions with other apps 487
    20. Using Slices 488
  22. Chapter 5: Interacting with the Users 491
    1. Creating a Great Layout 492
    2. Defining the View and ViewGroup elements 492
    3. Creating a layout using XML 493
    4. Modifying a layout at runtime 497
    5. Considering the common layouts 498
    6. Working with adapters 499
    7. Debugging your layout 500
    8. Employing Color and Texture 502
    9. Working with styles and themes 503
    10. Creating a palette 509
    11. Using swatches to create color schemes 510
    12. Using Animations and Transitions 510
    13. Understanding the need for animations 511
    14. Animating graphics 511
    15. Communicating with Emoji 514
    16. Keyboard emoji support 515
    17. Using the cut-and-paste method on standard controls 516
    18. Using the AndroidX approach 517
  23. Book 4: Programming Cool Phone Features 521
  24. Chapter 1: Hungry Burds: A Simple Android Game 523
    1. Introducing the Hungry Burds Game 523
    2. The Hungry Burds Project’s Files 526
    3. The Main Activity 528
    4. The Code, All the Code, and Nothing But the Code 530
    5. Setting Up the Game 535
    6. Declaring properties 535
    7. The onCreate Method 537
    8. Displaying a Burd 538
    9. Creating random values 538
    10. Creating a Burd 539
    11. Placing a Burd on the constraint layout 540
    12. Animating a Burd 542
    13. Handling a Touch Event 544
    14. Finishing Up 546
  25. Chapter 2: An Android Social Media App 547
    1. Setting Things Up on Facebook’s Developer Site 548
    2. A Minimal Facebook App 549
    3. The build.gradle file 550
    4. The manifest file 550
    5. A Bare-Bones Main Activity 551
    6. Enriching the Minimal App 555
    7. Working with a radio group 559
    8. Controlling the web view 562
    9. Who tests your Facebook app? 563
  26. Chapter 3: Going Native 567
    1. The Native Development Kit 567
    2. Understanding why you need the NDK 568
    3. Knowing what you get 569
    4. Getting the NDK 570
    5. Creating an Application 573
    6. Starting with the template 573
    7. Seeing the essential project differences 575
    8. Considering the build.gradle (Module: app) differences 577
    9. Understanding the default template differences 580
    10. Getting an overview of the C++ file 582
    11. Seeing the result 583
  27. Book 5: Apps for Tablets, Watches, TV Sets, and Cars 585
  28. Chapter 1: Apps for Tablets 587
    1. Gaining Perspective 588
    2. Creating the right devices 589
    3. Running code on multiple devices 593
    4. Copying the project 594
    5. Seeing presentation differences 596
    6. Developing a Nested Navigational Graph 603
    7. Understanding the uses for nested navigational graphs 603
    8. Developing an app design 604
    9. Considering the content needs 608
    10. Creating a Responsive App 612
  29. Chapter 2: Developing for Android Wear 615
    1. Seeing Where Wearables Are Used 615
    2. Setting Up Your Testing Environment 617
    3. Creating the project 617
    4. Configuring a wearable device emulator 620
    5. Other testing configurations 624
    6. Wearable Apps: What’s the Big Deal? 625
    7. Case Study: A Watch Face 626
    8. Defining the watch face project 627
    9. Testing the watch face app 628
    10. Dissecting the skeletal watch face project 631
    11. Enhancing the skeletal watch face project 634
  30. Chapter 3: Developing for Android TV 637
    1. Getting Started 638
    2. Running the Skeletal App 641
    3. Dissecting the TV App 644
    4. Adding to the standard AndroidManifest.xml 644
    5. Looking into build.gradle (Module: app) 645
    6. Defining a layout 646
    7. The adapter and the presenter 647
    8. Using the Adapter class 648
    9. Using the Presenter class 650
  31. Chapter 4: Developing for Android Auto 653
    1. Checking Auto Compatibility 654
    2. Choosing the Google Play Services 656
    3. Considering Notification Limits 658
    4. Creating an Emulator 660
    5. Configuring your car for development 661
    6. Defining an emulator 662
    7. Developing an Android Auto App 670
    8. Creating the project 670
    9. Viewing the project configuration 672
    10. Performing required configuration tasks 674
    11. Touring the Media Service app 675
  32. Book 6: The Job Isn’t Done Until 679
  33. Chapter 1: Publishing Your App to the Google Play Store 681
    1. Creating a Google Play Developer Account 681
    2. Preparing Your Code 682
    3. Un-testing the app 683
    4. Choosing Android versions 683
    5. Setting your app’s own version code and version name 684
    6. Choosing a package name 685
    7. Preparing Graphic Assets for the Play Store 685
    8. Creating an icon 686
    9. Creating screenshots 688
    10. Providing other visual assets 690
    11. Creating a Publishable File 691
    12. Differences among builds 692
    13. Creating the release build 697
    14. Running a new APK file 702
    15. Running the app in a new AAB file 703
    16. Another way to build and run an AAB file 705
    17. Publishing Your App 708
    18. The App Releases page 708
    19. The Store Listing page 710
    20. The App Signing page 711
    21. Other pages 711
    22. Leave No Stone Unturned 714
    23. Publishing Elsewhere 714
    24. The Amazon Appstore 714
    25. Other venues 715
  34. Chapter 2: Monetizing and Marketing Your App 717
    1. Choosing a Revenue Model 718
    2. Charging for your app 719
    3. Offering an extended free trial 723
    4. Freemium apps 724
    5. Selling things with your app 726
    6. Subscription pricing 729
    7. Earning revenue from advertising 729
    8. Variations on in-app advertising 731
    9. Donationware 732
    10. Offering your app for free 732
    11. Getting paid to develop apps for others 732
    12. Marketing Your Application 733
    13. Brick Breaker Master: An App Marketing Case Study 734
  35. Chapter 3: Creating Public Support for Your App 739
    1. Obtaining Support through Patreon 740
    2. Discovering that patronage isn’t new 740
    3. Considering crowdfunding 741
    4. Defining why you should use crowdfunding 741
    5. Understanding the development angle 742
    6. Determining the trade-offs 744
    7. Developing Your Own Distribution Stream 744
    8. Creating podcasts 744
    9. Developing YouTube videos 746
    10. Employing social media 748
    11. Answering questions 750
    12. Taking the Personal Approach 750
    13. Creating a blog 751
    14. Answering your email 752
    15. Considering App Store Alternatives 754
    16. Getting Awards 756
    17. Looking for awards in all the right places 757
    18. Strutting your stuff 757
    19. Index 759
Author Biography

Barry Burd, PhD, is a veteran author and educator. At the University of Illinois, he was five times elected to the university-wide List of Teachers Ranked as Excellent by their Students. He has written several books on Java and Android development. John Paul Mueller has produced 115 books and more than 600 articles on topics ranging from functional programming techniques to application development using C++.

Additional information
Weight1.458 kg
Reviews

There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.