Android Application Development All-in-One For Dummies

 
 
Standards Information Network (Verlag)
  • 3. Auflage
  • |
  • erschienen am 10. Juli 2020
  • |
  • 800 Seiten
 
E-Book | PDF mit Adobe-DRM | Systemvoraussetzungen
978-1-119-66046-0 (ISBN)
 
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.
3. Auflage
  • Englisch
  • Newark
  • |
  • USA
John Wiley & Sons Inc
  • Überarbeitete Ausgabe
  • 26,83 MB
978-1-119-66046-0 (9781119660460)
weitere Ausgaben werden ermittelt
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++.
  • Intro
  • 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 &brief& 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

Dateiformat: PDF
Kopierschutz: Adobe-DRM (Digital Rights Management)

Systemvoraussetzungen:

Computer (Windows; MacOS X; Linux): Installieren Sie bereits vor dem Download die kostenlose Software Adobe Digital Editions (siehe E-Book Hilfe).

Tablet/Smartphone (Android; iOS): Installieren Sie bereits vor dem Download die kostenlose App Adobe Digital Editions (siehe E-Book Hilfe).

E-Book-Reader: Bookeen, Kobo, Pocketbook, Sony, Tolino u.v.a.m. (nicht Kindle)

Das Dateiformat PDF zeigt auf jeder Hardware eine Buchseite stets identisch an. Daher ist eine PDF auch für ein komplexes Layout geeignet, wie es bei Lehr- und Fachbüchern verwendet wird (Bilder, Tabellen, Spalten, Fußnoten). Bei kleinen Displays von E-Readern oder Smartphones sind PDF leider eher nervig, weil zu viel Scrollen notwendig ist. Mit Adobe-DRM wird hier ein "harter" Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.

Bitte beachten Sie bei der Verwendung der Lese-Software Adobe Digital Editions: wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!

Weitere Informationen finden Sie in unserer E-Book Hilfe.


Download (sofort verfügbar)

28,99 €
inkl. 7% MwSt.
Download / Einzel-Lizenz
PDF mit Adobe-DRM
siehe Systemvoraussetzungen
E-Book bestellen