دانلود کتاب Android programming for dummies all-in-one

فهرست مطالب :

Title Page Copyright Page Table of Contents Introduction How to Use This Book Conventions Used in This Book Foolish Assumptions Icons Used in This Book Beyond the Book Where to Go from Here Book 1 Getting Started with Android Application Development Chapter 1 All about Android The Consumer Perspective The Versions of Android The Developer Perspective Java and Kotlin XML Linux The Business Perspective Chapter 2 Installing the Software Tools Setting Up the Software Considering the requirements Downloading the software Installing Android Studio Installing offline tools Launching the Android Studio IDE In Windows On a Mac In Linux In Chrome OS Using the Android Studio Setup Wizard Fattening Up the Android SDK The more things stay the same, the more they change Installing new versions (and older versions) of Android Creating an Android virtual device A third-party emulator Chapter 3 Creating an Android App Creating Your First App Starting the IDE and creating your first app Launching your first app Running Your App You Can Download All the Code Troubleshooting Common IDE Errors Error message: Failed to find target Error running ‘app’: No target device found Error message: Android Virtual Device may be incompatible with your configuration You lose contact with the Android Debug Bridge (ADB) You don’t like whatever AVD opens automatically The emulator stalls during startup Error message: The user data image is used by another emulator Error message: Unknown virtual device name The emulator displays a “process isn’t responding” dialog box Changes to your app don’t appear in the emulator Testing Apps on a Real Device Chapter 4 Examining a Basic Android App A Project’s Files The MainActivity.kt file The onCreate() method Using other templates The res Branch The res/drawable branch The res/layout branch The res/menu branch The res/mipmap branch The res/values branch Other Files in an Android Project The build.gradle file The AndroidManifest.xml file The R.java file The assets folder The android.jar archive The APK file What Did I Agree To? What’s in a name? Choosing a language Your app’s API levels Chapter 5 Conjuring and Embellishing an Android App Dragging, Dropping, and Otherwise Tweaking an App Creating the “look” Coding the behavior A Bit of Debugging Try it! Discovering the secrets of Logcat Using the debugger Chapter 6 Improving Your App Improving the Layout Changing the layout Creating a reusable layout Reusing a layout Starting Another Activity Localizing Your App Responding to Check Box Events Displaying Images Sending in Your Order Book 2 Android Background Material Chapter 1 Using Android Studio Good to Know versus Need to Know Getting a Feel for the Big Picture The main window Viewing modes The Designer tool Discovering What You Can Do Finding things Fixing code Refactoring Chapter 2 Kotlin for Java Programmers Using Kotlin or Java for Development Defining the Java Issues That Kotlin Fixes Improving control over null references Removing raw data types Using invariant arrays Working with proper function types Getting rid of the checked exceptions Nothing’s Perfect: Kotlin Is Missing Features, Too Considering primitive types that are not classes Losing static members Eliminating non-private fields Reducing confusion by eliminating wildcard-types Abandoning the ternary-operator a ? b : c Looking at What Kotlin Adds to the Picture Considering higher order functions and lambdas Refining object orientation using extension functions Relying on smart casts Employing string templates Understanding primary constructors Implementing first-class delegation Using ranges of values Creating data classes Overloading operators Developing asynchronous code using coroutines Chapter 3 Kotlin for Everyone Moving from Development to Execution with Kotlin What is a compiler? Understanding native code compiler or interpreter issues Considering the Android Runtime (ART) Grasping Kotlin Code Nearly everything begins with an expression The Kotlin class Classes and objects Kotlin types Performing casts The Kotlin function Objects and their constructors Classes grow on trees The Kotlin package Considering Kotlin visibility rules Defying your parent Kotlin comments Chapter 4 What Kotlin Does (and When) Making Decisions (Kotlin if Statements) Testing for equality Choosing among many alternatives (Kotlin when statements) Repeating Instructions Over and Over Again Kotlin while statements Kotlin do statements Arrays in Kotlin Kotlin’s for statements Looping using Kotlin recursion Working with break and continue Jumping Away from Trouble Working with Kotlin Collections Considering the collection types Differentiating between read-only and mutable collections Chapter 5 Object-Oriented Programming in Kotlin Static Fields and Methods Interfaces and Callbacks Event handling and callbacks An object remembers who created it A less wordy way to implement an interface Classes That Must (and Must Not) Be Extended The need to override Java’s final classes Kotlin’s open classes Kotlin extensions Abstract classes Inner Classes Named inner classes Anonymous inner classes Chapter 6 Functional Programming in Kotlin Defining Functional Programming Differences from other programming paradigms Understanding its goals Understanding Pure and Impure Languages Using the pure approach Using the impure approach Comparing the Functional Paradigm Using Kotlin for Functional Programming Needs Defining the Role of State Using Recursion to Perform Calculations Relying on standard recursion Relying on tail recursion Using Function Types Understanding Function Literals Lambda expressions Anonymous functions Defining the Function Types Comprehensions Receivers Inline Utility Using Functional Programming for Android Apps Chapter 7 A Look at XML XML Isn’t Ordinary Text Of tags and elements Other things you find in an XML document What’s in a Namespace? The package attribute The style attribute Book 3 The Building Blocks Chapter 1 Getting an Overview of Jetpack Understanding the Benefits of Jetpack Eliminating boilerplate code Managing background tasks Navigating between activities and fragments Managing memory Performing configuration changes Considering the Jetpack Components Foundation Architecture Behavior UI Getting an Overview of the AndroidX Package Working with Lifecycle-Aware Components Focusing on activities Understanding events and states Chapter 2 Building a Foundation for Your App Working with Android KTX Getting a feel for KTX features Using KTX in your project Considering the modules Addressing Security Issues Benchmarking Your Application Removing barriers to correct results Creating a test app Profiling your app Tracing your app Checking for benchmarking module support Benchmarking the app Testing Application Functionality Chapter 3 Creating an Architecture Managing Application Activities Defining an activity Getting an overview of intent filters Considering the activity lifecycle Understanding the backstack Working with fragments Considering the fragment lifecycle Seeing activities and fragments in action Providing for Navigational Needs Creating the navigational graph Adding a NavHostFragment to your activity Adding destinations Creating links between destinations Creating the required linkages Performing Background Tasks Using WorkManager Chapter 4 Defining an App’s Behavior Working with Notifications Understanding what notifications do Anatomy of a notification Assigning a channel to your notification Setting the notification importance Considering the notification types Relying on notification updates Do Not Disturb mode Creating a notification Getting Permission Considering permission use Configuring permissions in Android Manifest.xml Complying with User Preferences Deciding on a preference set Setting preferences using the Preference Library Working with MediaPlayer Adding Camera Support Using CameraX Sharing with Others Performing simple share actions with other apps Using Slices Chapter 5 Interacting with the Users Creating a Great Layout Defining the View and ViewGroup elements Creating a layout using XML Modifying a layout at runtime Considering the common layouts Working with adapters Debugging your layout Employing Color and Texture Working with styles and themes Creating a palette Using swatches to create color schemes Using Animations and Transitions Understanding the need for animations Animating graphics Communicating with Emoji Keyboard emoji support Using the cut-and-paste method on standard controls Using the AndroidX approach Book 4 Programming Cool Phone Features Chapter 1 Hungry Burds: A Simple Android Game Introducing the Hungry Burds Game The Hungry Burds Project’s Files The Main Activity The Code, All the Code, and Nothing But the Code Setting Up the Game Declaring properties The onCreate Method Displaying a Burd Creating random values Creating a Burd Placing a Burd on the constraint layout Animating a Burd Handling a Touch Event Finishing Up Chapter 2 An Android Social Media App Setting Things Up on Facebook’s Developer Site A Minimal Facebook App The build.gradle file The manifest file A Bare-Bones Main Activity Enriching the Minimal App Working with a radio group Controlling the web view Who tests your Facebook app? Chapter 3 Going Native The Native Development Kit Understanding why you need the NDK Knowing what you get Getting the NDK Creating an Application Starting with the template Seeing the essential project differences Considering the build.gradle (Module: app) differences Understanding the default template differences Getting an overview of the C++ file Seeing the result Book 5 Apps for Tablets, Watches, TV Sets, and Cars Chapter 1 Apps for Tablets Gaining Perspective Creating the right devices Running code on multiple devices Copying the project Seeing presentation differences Developing a Nested Navigational Graph Understanding the uses for nested navigational graphs Developing an app design Considering the content needs Creating a Responsive App Chapter 2 Developing for Android Wear Seeing Where Wearables Are Used Setting Up Your Testing Environment Creating the project Configuring a wearable device emulator Other testing configurations Wearable Apps: What’s the Big Deal? Case Study: A Watch Face Defining the watch face project Testing the watch face app Dissecting the skeletal watch face project Enhancing the skeletal watch face project Chapter 3 Developing for Android TV Getting Started Running the Skeletal App Dissecting the TV App Adding to the standard Android Manifest.xml Looking into build.gradle (Module: app) Defining a layout The adapter and the presenter Using the Adapter class Using the Presenter class Chapter 4 Developing for Android Auto Checking Auto Compatibility Choosing the Google Play Services Considering Notification Limits Creating an Emulator Configuring your car for development Defining an emulator Developing an Android Auto App Creating the Project Viewing the project configuration Performing required configuration tasks Touring the Media Service app Book 6 The Job Isn’t Done Until . . . Chapter 1 Publishing Your App to the Google Play Store Creating a Google Play Developer Account Preparing Your Code Un-testing the app Choosing Android versions Setting your app’s own version code and version name Choosing a package name Preparing Graphic Assets for the Play Store Creating an icon Creating screenshots Providing other visual assets Creating a Publishable File Differences among builds Creating the release build Running a new APK file Running the app in a new AAB file Another way to build and run an AAB file Publishing Your App The App Releases page The Store Listing page The App Signing page Other pages Leave No Stone Unturned Publishing Elsewhere The Amazon Appstore Other venues Chapter 2 Monetizing and Marketing Your App Choosing a Revenue Model Charging for your app Offering an extended free trial Freemium apps Selling things with your app Subscription pricing Earning revenue from advertising Variations on in-app advertising Donationware Offering your app for free Getting paid to develop apps for others Marketing Your Application Brick Breaker Master: An App Marketing Case Study Chapter 3 Creating Public Support for Your App Obtaining Support through Patreon Discovering that patronage isn’t new Considering crowdfunding Defining why you should use crowdfunding Understanding the development angle Determining the trade-offs Developing Your Own Distribution Stream Creating podcasts Developing YouTube videos Employing social media Answering questions Taking the Personal Approach Creating a blog Answering your email Considering App Store Alternatives Getting Awards Looking for awards in all the right places Strutting your stuff Index EULA