Android Studio 23 Development Essentials Neil Smyth Instant Download
Android Studio 23 Development Essentials Neil Smyth Instant Download
Smyth download
https://ebookbell.com/product/android-studio-23-development-
essentials-neil-smyth-50654020
https://ebookbell.com/product/android-studio-32-development-
essentials-kotlin-edition-developing-android-9-apps-using-android-
studio-32-kotlin-and-android-jetpack-smyth-35703616
https://ebookbell.com/product/android-studio-32-development-
essentials-kotlin-edition-developing-android-9-apps-using-android-
studio-32-kotlin-and-android-jetpack-neil-smyth-37362580
https://ebookbell.com/product/android-studio-32-development-
essentials-kotlin-edition-developing-android-9-apps-using-android-
studio-32-kotlin-and-android-jetpack-smyth-36015834
https://ebookbell.com/product/android-studio-2-essentials-2nd-edition-
zapata-belen-cruz-11858430
Android Studio 42 Development Essentials Java Edition Developing
Android Apps Using Android Studio 42 Java And Android Jetpack Neil
Smyth
https://ebookbell.com/product/android-studio-42-development-
essentials-java-edition-developing-android-apps-using-android-
studio-42-java-and-android-jetpack-neil-smyth-33967918
https://ebookbell.com/product/android-studio-42-development-
essentials-kotlin-edition-developing-android-apps-using-android-
studio-42-kotlin-and-android-jetpack-neil-smyth-33967924
https://ebookbell.com/product/android-studio-42-development-
essentials-kotlin-edition-developing-android-apps-using-android-
studio-42-kotlin-and-android-jetpack-smyth-32948188
https://ebookbell.com/product/android-studio-42-development-
essentials-java-edition-developing-android-apps-using-android-
studio-42-java-and-android-jetpack-neil-smyth-34707492
https://ebookbell.com/product/android-studio-flamingo-essentials-java-
edition-developing-android-apps-using-android-studio-202221-and-java-
neil-smyth-51142446
Android Studio 2.3 Development Essentials – Android 7 Edition
© 2017 Neil Smyth / Payload Media, Inc. All Rights Reserved.
This book is provided for personal use only. Unauthorized use, reproduction
and/or distribution strictly prohibited. All rights reserved.
The content of this book is provided for informational purposes only. Neither the
publisher nor the author offers any warranties or representation, express or
implied, with regard to the accuracy of information contained in this book, nor
do they accept any liability for any loss or damage arising from any errors or
omissions.
This book contains trademarked terms that are used solely for editorial purposes
and to the benefit of the respective trademark owner. The terms used within this
book are not intended as infringement of any trademarks.
Rev: 1.0
Table of Contents
1.Introduction
1.1 Downloading the Code Samples
1.2 Feedback
1.3 Errata
2.Setting up an Android Studio Development Environment
2.1 System Requirements
2.2 Installing the Java Development Kit (JDK)
2.2.1 Windows JDK Installation
2.2.2 Mac OS X JDK Installation
2.3 Linux JDK Installation
2.4 Downloading the Android Studio Package
2.5 Installing Android Studio
2.5.1 Installation on Windows
2.5.2 Installation on Mac OS X
2.5.3 Installation on Linux
2.6 The Android Studio Setup Wizard
2.7 Installing Additional Android SDK Packages
2.8 Making the Android SDK Tools Command-line Accessible
2.8.1 Windows 7
2.8.2 Windows 8.1
2.8.3 Windows 10
2.8.4 Linux
2.8.5 Mac OS X
2.9 Updating the Android Studio and the SDK
2.10 Summary
3.Creating an Example Android App in Android Studio
3.1 Creating a New Android Project
3.2 Defining the Project and SDK Settings
3.3 Creating an Activity
3.4 Modifying the Example Application
3.5 Reviewing the Layout and Resource Files
3.6 Summary
4.A Tour of the Android Studio User Interface
4.1 The Welcome Screen
4.2 The Main Window
4.3 The Tool Windows
4.4 Android Studio Keyboard Shortcuts
4.5 Switcher and Recent Files Navigation
4.6 Changing the Android Studio Theme
4.7 Summary
5.Creating an Android Virtual Device (AVD) in Android Studio
5.1 About Android Virtual Devices
5.2 Creating a New AVD
5.3 Starting the Emulator
5.4 Running the Application in the AVD
5.5 Run/Debug Configurations
5.6 Stopping a Running Application
5.7 AVD Command-line Creation
5.8 Android Virtual Device Configuration Files
5.9 Moving and Renaming an Android Virtual Device
5.10 Summary
6. Using and Configuring the Android Studio AVD Emulator
6.1 The Emulator Environment
6.2 The Emulator Toolbar Options
6.3 Working in Zoom Mode
6.4 Resizing the Emulator Window
6.5 Extended Control Options
6.5.1 Location
6.5.2 Cellular
6.5.3 Battery
6.5.4 Phone
6.5.5 Directional Pad
6.5.6 Fingerprint
6.5.7 Virtual Sensors
6.5.8 Settings
6.5.9 Help
6.6 Drag and Drop Support
6.7 Configuring Fingerprint Emulation
6.8 Summary
7.Testing Android Studio Apps on a Physical Android Device
7.1 An Overview of the Android Debug Bridge (ADB)
7.2 Enabling ADB on Android based Devices
7.2.1 Mac OS X ADB Configuration
7.2.2 Windows ADB Configuration
7.2.3 Linux adb Configuration
7.3 Testing the adb Connection
7.4 Summary
8.The Basics of the Android Studio Code Editor
8.1 The Android Studio Editor
8.2 Splitting the Editor Window
8.3 Code Completion
8.4 Statement Completion
8.5 Parameter Information
8.6 Code Generation
8.7 Code Folding
8.8 Quick Documentation Lookup
8.9 Code Reformatting
8.10 Finding Sample Code
8.11 Summary
9.An Overview of the Android Architecture
9.1 The Android Software Stack
9.2 The Linux Kernel
9.3 Android Runtime – ART
9.4 Android Libraries
9.4.1 C/C++ Libraries
9.5 Application Framework
9.6 Applications
9.7 Summary
10.The Anatomy of an Android Application
10.1 Android Activities
10.2 Android Intents
10.3 Broadcast Intents
10.4 Broadcast Receivers
10.5 Android Services
10.6 Content Providers
10.7 The Application Manifest
10.8 Application Resources
10.9 Application Context
10.10 Summary
11.Understanding Android Application and Activity Lifecycles
11.1 Android Applications and Resource Management
11.2 Android Process States
11.2.1 Foreground Process
11.2.2 Visible Process
11.2.3 Service Process
11.2.4 Background Process
11.2.5 Empty Process
11.3 InterProcess Dependencies
11.4 The Activity Lifecycle
11.5 The Activity Stack
11.6 Activity States
11.7 Configuration Changes
11.8 Handling State Change
11.9 Summary
12.Handling Android Activity State Changes
12.1 The Activity Class
12.2 Dynamic State vs. Persistent State
12.3 The Android Activity Lifecycle Methods
12.4 Activity Lifetimes
12.5 Disabling Configuration Change Restarts
12.6 Summary
13.Android Activity State Changes by Example
13.1 Creating the State Change Example Project
13.2 Designing the User Interface
13.3 Overriding the Activity Lifecycle Methods
13.4 Filtering the LogCat Panel
13.5 Running the Application
13.6 Experimenting with the Activity
13.7 Summary
14.Saving and Restoring the State of an Android Activity
14.1 Saving Dynamic State
14.2 Default Saving of User Interface State
14.3 The Bundle Class
14.4 Saving the State
14.5 Restoring the State
14.6 Testing the Application
14.7 Summary
15.Understanding Android Views, View Groups and Layouts
15.1 Designing for Different Android Devices
15.2 Views and View Groups
15.3 Android Layout Managers
15.4 The View Hierarchy
15.5 Creating User Interfaces
15.6 Summary
16.A Guide to the Android Studio Layout Editor Tool
16.1 Basic vs. Empty Activity Templates
16.2 The Android Studio Layout Editor
16.3 Design Mode
16.4 The Palette
16.5 Pan and Zoom
16.6 Design and Layout Views
16.7 Text Mode
16.8 Setting Properties
16.9 Configuring Favorite Attributes
16.10 Creating a Custom Device Definition
16.11 Changing the Current Device
16.12 Summary
17.A Guide to the Android ConstraintLayout
17.1 How ConstraintLayout Works
17.1.1 Constraints
17.1.2 Margins
17.1.3 Opposing Constraints
17.1.4 Constraint Bias
17.1.5 Chains
17.1.6 Chain Styles
17.2 Baseline Alignment
17.3 Working with Guidelines
17.4 Configuring Widget Dimensions
17.5 Ratios
17.6 ConstraintLayout Advantages
17.7 ConstraintLayout Availability
17.8 Summary
18.A Guide to using ConstraintLayout in Android Studio
18.1 Design and Layout Views
18.2 Autoconnect Mode
18.3 Inference Mode
18.4 Manipulating Constraints Manually
18.5 Deleting Constraints
18.6 Adjusting Constraint Bias
18.7 Understanding ConstraintLayout Margins
18.8 The Importance of Opposing Constraints and Bias
18.9 Configuring Widget Dimensions
18.10 Adding Guidelines
18.11 Widget Group Alignment
18.12 Converting other Layouts to ConstraintLayout
18.13 Summary
19.Working with ConstraintLayout Chains and Ratios in Android Studio
19.1 Creating a Chain
19.2 Changing the Chain Style
19.3 Spread Inside Chain Style
19.4 Packed Chain Style
19.5 Packed Chain Style with Bias
19.6 Weighted Chain
19.7 Working with Ratios
19.8 Summary
20.An Android Studio Layout Editor ConstraintLayout Tutorial
20.1 An Android Studio Layout Editor Tool Example
20.2 Creating a New Activity
20.3 Preparing the Layout Editor Environment
20.4 Adding the Widgets to the User Interface
20.5 Adding the Constraints
20.6 Testing the Layout
20.7 Using the Layout Inspector
20.8 Using the Hierarchy Viewer
20.9 Summary
21.Manual XML Layout Design in Android Studio
21.1 Manually Creating an XML Layout
21.2 Manual XML vs. Visual Layout Design
21.3 Summary
22.Managing Constraints using Constraint Sets
22.1 Java Code vs. XML Layout Files
22.2 Creating Views
22.3 View Properties
22.4 Constraint Sets
22.4.1 Establishing Connections
22.4.2 Applying Constraints to a Layout
22.4.3 Parent Constraint Connections
22.4.4 Sizing Constraints
22.4.5 Constraint Bias
22.4.6 Alignment Constraints
22.4.7 Copying and Applying Constraint Sets
22.4.8 ConstraintLayout Chains
22.4.9 Guidelines
22.4.10 Removing Constraints
22.4.11 Scaling
22.4.12 Rotation
22.5 Summary
23.An Android ConstraintSet Tutorial
23.1 Creating the Example Project in Android Studio
23.2 Adding Views to an Activity
23.3 Setting View Properties
23.4 Creating View IDs
23.5 Configuring the Constraint Set
23.6 Adding the EditText View
23.7 Converting Density Independent Pixels (dp) to Pixels (px)
23.8 Summary
24.An Overview and Example of Android Event Handling
24.1 Understanding Android Events
24.2 Using the android:onClick Resource
24.3 Event Listeners and Callback Methods
24.4 An Event Handling Example
24.5 Designing the User Interface
24.6 The Event Listener and Callback Method
24.7 Consuming Events
24.8 Summary
25. A Guide to using Instant Run in Android Studio
25.1 Introducing Instant Run
25.2 Understanding Instant Run Swapping Levels
25.3 Enabling and Disabling Instant Run
25.4 Using Instant Run
25.5 An Instant Run Tutorial
25.6 Triggering an Instant Run Hot Swap
25.7 Triggering an Instant Run Warm Swap
25.8 Triggering an Instant Run Cold Swap
25.9 The Run Button
25.10 Summary
26.Android Touch and Multi-touch Event Handling
26.1 Intercepting Touch Events
26.2 The MotionEvent Object
26.3 Understanding Touch Actions
26.4 Handling Multiple Touches
26.5 An Example Multi-Touch Application
26.6 Designing the Activity User Interface
26.7 Implementing the Touch Event Listener
26.8 Running the Example Application
26.9 Summary
27.Detecting Common Gestures using the Android Gesture Detector Class
27.1 Implementing Common Gesture Detection
27.2 Creating an Example Gesture Detection Project
27.3 Implementing the Listener Class
27.4 Creating the GestureDetectorCompat Instance
27.5 Implementing the onTouchEvent() Method
27.6 Testing the Application
27.7 Summary
28.Implementing Custom Gesture and Pinch Recognition on Android
28.1 The Android Gesture Builder Application
28.2 The GestureOverlayView Class
28.3 Detecting Gestures
28.4 Identifying Specific Gestures
28.5 Building and Running the Gesture Builder Application
28.6 Creating a Gestures File
28.7 Extracting the Gestures File from the SD Card
28.8 Creating the Example Project
28.9 Adding the Gestures File to the Project
28.10 Designing the User Interface
28.11 Loading the Gestures File
28.12 Registering the Event Listener
28.13 Implementing the onGesturePerformed Method
28.14 Testing the Application
28.15 Configuring the GestureOverlayView
28.16 Intercepting Gestures
28.17 Detecting Pinch Gestures
28.18 A Pinch Gesture Example Project
28.19 Summary
29.An Introduction to Android Fragments
29.1 What is a Fragment?
29.2 Creating a Fragment
29.3 Adding a Fragment to an Activity using the Layout XML File
29.4 Adding and Managing Fragments in Code
29.5 Handling Fragment Events
29.6 Implementing Fragment Communication
29.7 Summary
30.Using Fragments in Android Studio - An Example
30.1 About the Example Fragment Application
30.2 Creating the Example Project
30.3 Creating the First Fragment Layout
30.4 Creating the First Fragment Class
30.5 Creating the Second Fragment Layout
30.6 Adding the Fragments to the Activity
30.7 Making the Toolbar Fragment Talk to the Activity
30.8 Making the Activity Talk to the Text Fragment
30.9 Testing the Application
30.10 Summary
31.Creating and Managing Overflow Menus on Android
31.1 The Overflow Menu
31.2 Creating an Overflow Menu
31.3 Displaying an Overflow Menu
31.4 Responding to Menu Item Selections
31.5 Creating Checkable Item Groups
31.6 Menus and the Android Studio Menu Editor
31.7 Creating the Example Project
31.8 Designing the Menu
31.9 Modifying the onOptionsItemSelected() Method
31.10 Testing the Application
31.11 Summary
32.Animating User Interfaces with the Android Transitions Framework
32.1 Introducing Android Transitions and Scenes
32.2 Using Interpolators with Transitions
32.3 Working with Scene Transitions
32.4 Custom Transitions and TransitionSets in Code
32.5 Custom Transitions and TransitionSets in XML
32.6 Working with Interpolators
32.7 Creating a Custom Interpolator
32.8 Using the beginDelayedTransition Method
32.9 Summary
33.An Android Transition Tutorial using beginDelayedTransition
33.1 Creating the Android Studio TransitionDemo Project
33.2 Preparing the Project Files
33.3 Implementing beginDelayedTransition Animation
33.4 Customizing the Transition
33.5 Summary
34.Implementing Android Scene Transitions – A Tutorial
34.1 An Overview of the Scene Transition Project
34.2 Creating the Android Studio SceneTransitions Project
34.3 Identifying and Preparing the Root Container
34.4 Designing the First Scene
34.5 Designing the Second Scene
34.6 Entering the First Scene
34.7 Loading Scene 2
34.8 Implementing the Transitions
34.9 Adding the Transition File
34.10 Loading and Using the Transition Set
34.11 Configuring Additional Transitions
34.12 Summary
35.Working with the Floating Action Button and Snackbar
35.1 The Material Design
35.2 The Design Library
35.3 The Floating Action Button (FAB)
35.4 The Snackbar
35.5 Creating the Example Project
35.6 Reviewing the Project
35.7 Changing the Floating Action Button
35.8 Adding the ListView to the Content Layout
35.9 Adding Items to the ListView
35.10 Adding an Action to the Snackbar
35.11 Summary
36.Creating a Tabbed Interface using the TabLayout Component
36.1 An Introduction to the ViewPager
36.2 An Overview of the TabLayout Component
36.3 Creating the TabLayoutDemo Project
36.4 Creating the First Fragment
36.5 Duplicating the Fragments
36.6 Adding the TabLayout and ViewPager
36.7 Creating the Pager Adapter
36.8 Performing the Initialization Tasks
36.9 Testing the Application
36.10 Customizing the TabLayout
36.11 Displaying Icon Tab Items
36.12 Summary
37.Working with the RecyclerView and CardView Widgets
37.1 An Overview of the RecyclerView
37.2 An Overview of the CardView
37.3 Adding the Libraries to the Project
37.4 Summary
38.An Android RecyclerView and CardView Tutorial
38.1 Creating the CardDemo Project
38.2 Removing the Floating Action Button
38.3 Adding the RecyclerView and CardView Libraries
38.4 Designing the CardView Layout
38.5 Adding the RecyclerView
38.6 Creating the RecyclerView Adapter
38.7 Adding the Image Files
38.8 Initializing the RecyclerView Component
38.9 Testing the Application
38.10 Responding to Card Selections
38.11 Summary
39.Working with the AppBar and Collapsing Toolbar Layouts
39.1 The Anatomy of an AppBar
39.2 The Example Project
39.3 Coordinating the RecyclerView and Toolbar
39.4 Introducing the Collapsing Toolbar Layout
39.5 Changing the Title and Scrim Color
39.6 Summary
40.Implementing an Android Navigation Drawer
40.1 An Overview of the Navigation Drawer
40.2 Opening and Closing the Drawer
40.3 Responding to Drawer Item Selections
40.4 Using the Navigation Drawer Activity Template
40.5 Creating the Navigation Drawer Template Project
40.6 The Template Layout Resource Files
40.7 The Header Coloring Resource File
40.8 The Template Menu Resource File
40.9 The Template Code
40.10 Running the App
40.11 Summary
41.An Android Studio Master/Detail Flow Tutorial
41.1 The Master/Detail Flow
41.2 Creating a Master/Detail Flow Activity
41.3 The Anatomy of the Master/Detail Flow Template
41.4 Modifying the Master/Detail Flow Template
41.5 Changing the Content Model
41.6 Changing the Detail Pane
41.7 Modifying the WebsiteDetailFragment Class
41.8 Modifying the WebsiteListActivity Class
41.9 Adding Manifest Permissions
41.10 Running the Application
41.11 Summary
42.An Overview of Android Intents
42.1 An Overview of Intents
42.2 Explicit Intents
42.3 Returning Data from an Activity
42.4 Implicit Intents
42.5 Using Intent Filters
42.6 Checking Intent Availability
42.7 Summary
43.Android Explicit Intents – A Worked Example
43.1 Creating the Explicit Intent Example Application
43.2 Designing the User Interface Layout for ActivityA
43.3 Creating the Second Activity Class
43.4 Designing the User Interface Layout for ActivityB
43.5 Reviewing the Application Manifest File
43.6 Creating the Intent
43.7 Extracting Intent Data
43.8 Launching ActivityB as a Sub-Activity
43.9 Returning Data from a Sub-Activity
43.10 Testing the Application
43.11 Summary
44.Android Implicit Intents – A Worked Example
44.1 Creating the Android Studio Implicit Intent Example Project
44.2 Designing the User Interface
44.3 Creating the Implicit Intent
44.4 Adding a Second Matching Activity
44.5 Adding the Web View to the UI
44.6 Obtaining the Intent URL
44.7 Modifying the MyWebView Project Manifest File
44.8 Installing the MyWebView Package on a Device
44.9 Testing the Application
44.10 Summary
45.Android Broadcast Intents and Broadcast Receivers
45.1 An Overview of Broadcast Intents
45.2 An Overview of Broadcast Receivers
45.3 Obtaining Results from a Broadcast
45.4 Sticky Broadcast Intents
45.5 The Broadcast Intent Example
45.6 Creating the Example Application
45.7 Creating and Sending the Broadcast Intent
45.8 Creating the Broadcast Receiver
45.9 Configuring a Broadcast Receiver in the Manifest File
45.10 Testing the Broadcast Example
45.11 Listening for System Broadcasts
45.12 Summary
46.A Basic Overview of Threads and Thread Handlers
46.1 An Overview of Threads
46.2 The Application Main Thread
46.3 Thread Handlers
46.4 A Basic Threading Example
46.5 Creating a New Thread
46.6 Implementing a Thread Handler
46.7 Passing a Message to the Handler
46.8 Summary
47.An Overview of Android Started and Bound Services
47.1 Started Services
47.2 Intent Service
47.3 Bound Service
47.4 The Anatomy of a Service
47.5 Controlling Destroyed Service Restart Options
47.6 Declaring a Service in the Manifest File
47.7 Starting a Service Running on System Startup
47.8 Summary
48.Implementing an Android Started Service – A Worked Example
48.1 Creating the Example Project
48.2 Creating the Service Class
48.3 Adding the Service to the Manifest File
48.4 Starting the Service
48.5 Testing the IntentService Example
48.6 Using the Service Class
48.7 Creating the New Service
48.8 Modifying the User Interface
48.9 Running the Application
48.10 Creating a New Thread for Service Tasks
48.11 Summary
49.Android Local Bound Services – A Worked Example
49.1 Understanding Bound Services
49.2 Bound Service Interaction Options
49.3 An Android Studio Local Bound Service Example
49.4 Adding a Bound Service to the Project
49.5 Implementing the Binder
49.6 Binding the Client to the Service
49.7 Completing the Example
49.8 Testing the Application
49.9 Summary
50.Android Remote Bound Services – A Worked Example
50.1 Client to Remote Service Communication
50.2 Creating the Example Application
50.3 Designing the User Interface
50.4 Implementing the Remote Bound Service
50.5 Configuring a Remote Service in the Manifest File
50.6 Launching and Binding to the Remote Service
50.7 Sending a Message to the Remote Service
50.8 Summary
51.An Android 7 Notifications Tutorial
51.1 An Overview of Notifications
51.2 Creating the NotifyDemo Project
51.3 Designing the User Interface
51.4 Creating the Second Activity
51.5 Creating and Issuing a Basic Notification
51.6 Launching an Activity from a Notification
51.7 Adding Actions to a Notification
51.8 Adding Sound to a Notification
51.9 Bundled Notifications
51.10 Summary
52.An Android 7 Direct Reply Notification Tutorial
52.1 Creating the DirectReply Project
52.2 Designing the User Interface
52.3 Building the RemoteInput Object
52.4 Creating the PendingIntent
52.5 Creating the Reply Action
52.6 Receiving Direct Reply Input
52.7 Updating the Notification
52.8 Summary
53.Integrating Firebase Support into an Android Studio Project
53.1 What is Firebase?
53.2 Signing in to Firebase
53.3 Creating the FirebaseNotify Project
53.4 Configuring the User Interface
53.5 Connecting the Project to Firebase
53.6 Creating a New Firebase Project
53.7 The google-services.json File
53.8 Adding the Firebase Libraries
53.9 Summary
54.An Android 7 Firebase Remote Notification Tutorial
54.1 Sending a Firebase Notification
54.2 Receiving the Notification
54.3 Including Custom Data within the Notification
54.4 Foreground App Notification Handling
54.5 Summary
55.An Introduction to Android 7 MultiWindow Support
55.1 Split-Screen, Freeform and Picture-in-Picture Modes
55.2 Entering MultiWindow Mode
55.3 Checking for Freeform Support
55.4 Enabling MultiWindow Support in an App
55.5 Specifying MultiWindow Attributes
55.6 Detecting MultiWindow Mode in an Activity
55.7 Receiving MultiWindow Notifications
55.8 Launching an Activity in MultiWindow Mode
55.9 Configuring Freeform Activity Size and Position
55.10 Summary
56.An Android Studio MultiWindow Split-Screen and Freeform Tutorial
56.1 Creating the MultiWindow Project
56.2 Designing the FirstActivity User Interface
56.3 Adding the Second Activity
56.4 Launching the Second Activity
56.5 Enabling MultiWindow Mode
56.6 Testing MultiWindow Support
56.7 Launching the Second Activity in a Different Window
56.8 Changing the Freeform Window Position and Size
56.9 Summary
57.An Overview of Android SQLite Databases
57.1 Understanding Database Tables
57.2 Introducing Database Schema
57.3 Columns and Data Types
57.4 Database Rows
57.5 Introducing Primary Keys
57.6 What is SQLite?
57.7 Structured Query Language (SQL)
57.8 Trying SQLite on an Android Virtual Device (AVD)
57.9 Android SQLite Java Classes
57.9.1 Cursor
57.9.2 SQLiteDatabase
57.9.3 SQLiteOpenHelper
57.9.4 ContentValues
57.10 Summary
58.An Android TableLayout and TableRow Tutorial
58.1 The TableLayout and TableRow Layout Views
58.2 Creating the Database Project
58.3 Adding the TableLayout to the User Interface
58.4 Configuring the TableRows
58.5 Adding the Button Bar to the Layout
58.6 Adjusting the Layout Margins
58.7 Summary
59.An Android SQLite Database Tutorial
59.1 About the Database Example
59.2 Creating the Data Model
59.3 Implementing the Data Handler
59.3.1 The Add Handler Method
59.3.2 The Query Handler Method
59.3.3 The Delete Handler Method
59.4 Implementing the Activity Event Methods
59.5 Testing the Application
59.6 Summary
60.Understanding Android Content Providers
60.1 What is a Content Provider?
60.2 The Content Provider
60.2.1 onCreate()
60.2.2 query()
60.2.3 insert()
60.2.4 update()
60.2.5 delete()
60.2.6 getType()
60.3 The Content URI
60.4 The Content Resolver
60.5 The <provider> Manifest Element
60.6 Summary
61.Implementing an Android Content Provider in Android Studio
61.1 Copying the Database Project
61.2 Adding the Content Provider Package
61.3 Creating the Content Provider Class
61.4 Constructing the Authority and Content URI
61.5 Implementing URI Matching in the Content Provider
61.6 Implementing the Content Provider onCreate() Method
61.7 Implementing the Content Provider insert() Method
61.8 Implementing the Content Provider query() Method
61.9 Implementing the Content Provider update() Method
61.10 Implementing the Content Provider delete() Method
61.11 Declaring the Content Provider in the Manifest File
61.12 Modifying the Database Handler
61.13 Summary
62.Accessing Cloud Storage using the Android Storage Access Framework
62.1 The Storage Access Framework
62.2 Working with the Storage Access Framework
62.3 Filtering Picker File Listings
62.4 Handling Intent Results
62.5 Reading the Content of a File
62.6 Writing Content to a File
62.7 Deleting a File
62.8 Gaining Persistent Access to a File
62.9 Summary
63.An Android Storage Access Framework Example
63.1 About the Storage Access Framework Example
63.2 Creating the Storage Access Framework Example
63.3 Designing the User Interface
63.4 Declaring Request Codes
63.5 Creating a New Storage File
63.6 The onActivityResult() Method
63.7 Saving to a Storage File
63.8 Opening and Reading a Storage File
63.9 Testing the Storage Access Application
63.10 Summary
64.Implementing Video Playback on Android using the VideoView and
MediaController Classes
64.1 Introducing the Android VideoView Class
64.2 Introducing the Android MediaController Class
64.3 Testing Video Playback
64.4 Creating the Video Playback Example
64.5 Designing the VideoPlayer Layout
64.6 Configuring the VideoView
64.7 Adding Internet Permission
64.8 Adding the MediaController to the Video View
64.9 Setting up the onPreparedListener
64.10 Summary
65.Video Recording and Image Capture on Android using Camera Intents
65.1 Checking for Camera Support
65.2 Calling the Video Capture Intent
65.3 Calling the Image Capture Intent
65.4 Creating an Android Studio Video Recording Project
65.5 Designing the User Interface Layout
65.6 Checking for the Camera
65.7 Launching the Video Capture Intent
65.8 Handling the Intent Return
65.9 Testing the Application
65.10 Summary
66.Making Runtime Permission Requests in Android
66.1 Understanding Normal and Dangerous Permissions
66.2 Creating the Permissions Example Project
66.3 Checking for a Permission
66.4 Requesting Permission at Runtime
66.5 Providing a Rationale for the Permission Request
66.6 Testing the Permissions App
66.7 Summary
67.Android Audio Recording and Playback using MediaPlayer and
MediaRecorder
67.1 Playing Audio
67.2 Recording Audio and Video using the MediaRecorder Class
67.3 About the Example Project
67.4 Creating the AudioApp Project
67.5 Designing the User Interface
67.6 Checking for Microphone Availability
67.7 Performing the Activity Initialization
67.8 Implementing the recordAudio() Method
67.9 Implementing the stopAudio() Method
67.10 Implementing the playAudio() method
67.11 Configuring and Requesting Permissions
67.12 Testing the Application
67.13 Summary
68.Working with the Google Maps Android API in Android Studio
68.1 The Elements of the Google Maps Android API
68.2 Creating the Google Maps Project
68.3 Obtaining Your Developer Signature
68.4 Testing the Application
68.5 Understanding Geocoding and Reverse Geocoding
68.6 Adding a Map to an Application
68.7 Requesting Current Location Permission
68.8 Displaying the User’s Current Location
68.9 Changing the Map Type
68.10 Displaying Map Controls to the User
68.11 Handling Map Gesture Interaction
68.11.1 Map Zooming Gestures
68.11.2 Map Scrolling/Panning Gestures
68.11.3 Map Tilt Gestures
68.11.4 Map Rotation Gestures
68.12 Creating Map Markers
68.13 Controlling the Map Camera
68.14 Summary
69.Printing with the Android Printing Framework
69.1 The Android Printing Architecture
69.2 The Print Service Plugins
69.3 Google Cloud Print
69.4 Printing to Google Drive
69.5 Save as PDF
69.6 Printing from Android Devices
69.7 Options for Building Print Support into Android Apps
69.7.1 Image Printing
69.7.2 Creating and Printing HTML Content
69.7.3 Printing a Web Page
69.7.4 Printing a Custom Document
69.8 Summary
70.An Android HTML and Web Content Printing Example
70.1 Creating the HTML Printing Example Application
70.2 Printing Dynamic HTML Content
70.3 Creating the Web Page Printing Example
70.4 Removing the Floating Action Button
70.5 Designing the User Interface Layout
70.6 Loading the Web Page into the WebView
70.7 Adding the Print Menu Option
70.8 Summary
71.A Guide to Android Custom Document Printing
71.1 An Overview of Android Custom Document Printing
71.1.1 Custom Print Adapters
71.2 Preparing the Custom Document Printing Project
71.3 Creating the Custom Print Adapter
71.4 Implementing the onLayout() Callback Method
71.5 Implementing the onWrite() Callback Method
71.6 Checking a Page is in Range
71.7 Drawing the Content on the Page Canvas
71.8 Starting the Print Job
71.9 Testing the Application
71.10 Summary
72.An Android Fingerprint Authentication Tutorial
72.1 An Overview of Fingerprint Authentication
72.2 Creating the Fingerprint Authentication Project
72.3 Configuring Device Fingerprint Authentication
72.4 Adding the Fingerprint Permission to the Manifest File
72.5 Adding the Fingerprint Icon
72.6 Designing the User Interface
72.7 Accessing the Keyguard and Fingerprint Manager Services
72.8 Checking the Security Settings
72.9 Accessing the Android Keystore and KeyGenerator
72.10 Generating the Key
72.11 Initializing the Cipher
72.12 Creating the CryptoObject Instance
72.13 Implementing the Fingerprint Authentication Handler Class
72.14 Testing the Project
72.15 Summary
73.Handling Different Android Devices and Displays
73.1 Handling Different Device Displays
73.2 Creating a Layout for each Display Size
73.3 Creating Layout Variants in Android Studio
73.4 Providing Different Images
73.5 Checking for Hardware Support
73.6 Providing Device Specific Application Binaries
73.7 Summary
74.Signing and Preparing an Android Application for Release
74.1 The Release Preparation Process
74.2 Changing the Build Variant
74.3 Enabling ProGuard
74.4 Creating a Keystore File
74.5 Generating a Private Key
74.6 Creating the Application APK File
74.7 Register for a Google Play Developer Console Account
74.8 Uploading New APK Versions to the Google Play Developer Console
74.9 Analyzing the APK File
74.10 Summary
75. Integrating Google Play In-app Billing into an Android Application
75.1 Installing the Google Play Billing Library
75.2 Creating the Example In-app Billing Project
75.3 Adding Billing Permission to the Manifest File
75.4 Adding the IInAppBillingService.aidl File to the Project
75.5 Adding the Utility Classes to the Project
75.6 Designing the User Interface
75.7 Implementing the “Click Me” Button
75.8 Google Play Developer Console and Google Wallet Accounts
75.9 Obtaining the Public License Key for the Application
75.10 Setting Up Google Play Billing in the Application
75.11 Initiating a Google Play In-app Billing Purchase
75.12 Implementing the onActivityResult Method
75.13 Implementing the Purchase Finished Listener
75.14 Consuming the Purchased Item
75.15 Releasing the IabHelper Instance
75.16 Modifying the Security.java File
75.17 Testing the In-app Billing Application
75.18 Building a Release APK
75.19 Creating a New In-app Product
75.20 Publishing the Application to the Alpha Distribution Channel
75.21 Adding In-app Billing Test Accounts
75.22 Configuring Group Testing
75.23 Resolving Problems with In-App Purchasing
75.24 Summary
76. An Overview of Gradle in Android Studio
76.1 An Overview of Gradle
76.2 Gradle and Android Studio
76.2.1 Sensible Defaults
76.2.2 Dependencies
76.2.3 Build Variants
76.2.4 Manifest Entries
76.2.5 APK Signing
76.2.6 ProGuard Support
76.3 The Top-level Gradle Build File
76.4 Module Level Gradle Build Files
76.5 Configuring Signing Settings in the Build File
76.6 Running Gradle Tasks from the Command-line
76.7 Summary
77. An Android Studio Gradle Build Variants Example
77.1 Creating the Build Variant Example Project
77.2 Adding the Build Flavors to the Module Build File
77.3 Adding the Flavors to the Project Structure
77.4 Adding Resource Files to the Flavors
77.5 Testing the Build Flavors
77.6 Build Variants and Class Files
77.7 Adding Packages to the Build Flavors
77.8 Customizing the Activity Classes
77.9 Summary
1. Introduction
Fully updated for Android Studio 2.3 and Android 7, the goal of this book is to
teach the skills necessary to develop Android based applications using the
Android Studio Integrated Development Environment (IDE) and the Android 7
Software Development Kit (SDK).
Beginning with the basics, this book provides an outline of the steps necessary to
set up an Android development and testing environment. An overview of
Android Studio is included covering areas such as tool windows, the code editor
and the Layout Editor tool. An introduction to the architecture of Android is
followed by an in-depth look at the design of Android applications and user
interfaces using the Android Studio environment. More advanced topics such as
database management, content providers and intents are also covered, as are
touch screen handling, gesture recognition, camera access and the playback and
recording of both video and audio. This edition of the book also covers printing,
transitions and cloud-based file storage.
The concepts of material design are also covered in detail, including the use of
floating action buttons, Snackbars, tabbed interfaces, card views, navigation
drawers and collapsing toolbars.
In addition to covering general Android development techniques, the book also
includes Google Play specific topics such as implementing maps using the
Google Maps Android API, in-app billing and submitting apps to the Google
Play Developer Console.
The key new features of Android Studio and Android 7 are also covered in detail
including the new Layout Editor, the ConstraintLayout and ConstraintSet
classes, constraint chains, direct reply notifications, Firebase remote
notifications and multiwindow support.
Chapters also cover advanced features of Android Studio such as Gradle build
configuration and the implementation of build variants to target multiple
Android device types from a single project code base.
Assuming you already have some Java programming experience, are ready to
download Android Studio and the Android SDK, have access to a Windows,
Mac or Linux system and ideas for some apps to develop, you are ready to get
started.
1.1 Downloading the Code Samples
The source code and Android Studio project files for the examples contained in
this book are available for download at:
http://www.ebookfrenzy.com/retail/androidstudio23/index.php
The steps to load a project from the code samples into Android Studio are as
follows:
1. From the Welcome to Android Studio dialog, select the Open an existing
Android Studio project option.
2. In the project selection dialog, navigate to and select the folder containing
the project to be imported and click on OK.
1.2 Feedback
We want you to be satisfied with your purchase of this book. If you find any
errors in the book, or have any comments, questions or concerns please contact
us at [email protected].
1.3 Errata
While we make every effort to ensure the accuracy of the content of this book, it
is inevitable that a book covering a subject area of this size and complexity may
include some errors and oversights. Any known issues with the book will be
outlined, together with solutions, at the following URL:
http://www.ebookfrenzy.com/errata/androidstudio23.html
In the event that you find an error not listed in the errata, please let us know by
emailing our technical support team at [email protected]. They are
there to help you and will work to resolve any problems you may encounter.
2. Setting up an Android Studio Development
Environment
Before any work can begin on the development of an Android application, the
first step is to configure a computer system to act as the development platform.
This involves a number of steps consisting of installing the Java Development
Kit (JDK) and the Android Studio Integrated Development Environment (IDE)
which also includes the Android Software Development Kit (SDK).
This chapter will cover the steps necessary to install the requisite components for
Android application development on Windows, Mac OS X and Linux based
systems.
2.1 System Requirements
Android application development may be performed on any of the following
system types:
· Windows 7/8/10 (32-bit or 64-bit)
· Mac OS X 10.10 or later (Intel based systems only)
· Linux systems with version 2.19 or later of GNU C Library (glibc)
· Minimum of 2GB of RAM (8GB is preferred)
· Approximately 4GB of available disk space
· 1280 x 800 minimum screen resolution
Assuming that Java is currently installed, output similar to the following will
appear in the terminal window:
java version "1.8.0_77"
Java(TM) SE Runtime Environment (build 1.8.0_77-b03)
Java HotSpot(TM) 64-Bit Server VM (build 25.77-b03, mixed mode)
In the event that Java is not installed, issuing the “java” command in the terminal
window will result in the appearance of a message which reads as follows
together with a dialog on the desktop providing a More Info button which, when
clicked will display the Oracle Java web page:
No Java runtime present, requesting install
On the Oracle Java web page, locate and download the Java SE 8 JDK
installation package for Mac OS X.
Open the downloaded disk image (.dmg file) and double-click on the icon to
install the Java package (Figure 2-1):
Figure 2-1
The Java for OS X installer window will appear and take you through the steps
involved in installing the JDK. Once the installation is complete, return to the
Terminal window and run the following command, at which point the previously
outlined Java version information should appear:
java -version
To install using the compressed tar package (tar.gz) perform the following steps:
1. Create the directory into which the JDK is to be installed (for the purposes of
this example we will assume homedemo/java).
2. Download the appropriate tar.gz package from the Oracle web site into the
directory.
3. Execute the following command (where <jdk-file> is replaced by the name of
the downloaded JDK file):
tar xvfz <jdk-file>.tar.gz
This can typically be achieved by adding a command to the .bashrc file in your
home directory (specifics may differ depending on the particular Linux
distribution in use). For example, change directory to your home directory, edit
the .bashrc file contained therein and add the following line at the end of the file
(modifying the path to match the location of the JDK on your system):
export PATH=homedemo/java/jdk1.8.0_77/bin:$PATH
Having saved the change, future terminal sessions will include the JDK in the
$PATH environment variable.
2.4 Downloading the Android Studio Package
Most of the work involved in developing applications for Android will be
performed using the Android Studio environment. The content and examples in
this book were created based on Android Studio version 2.3.
Android Studio is subject to frequent updates and it is possible, therefore, that a
more recent release of Android Studio is now available. For the purposes of
compatibility with the tutorials and examples, however, it is recommended that
this book be used with Android Studio version 2.3 which may be downloaded
from the following web page:
http://tools.android.com/download/studio/builds/2-3-0
From this page, select and download the appropriate package for your platform
and operating system.
2.5 Installing Android Studio
Once downloaded, the exact steps to install Android Studio differ depending on
the operating system on which the installation is being performed.
2.5.1 Installation on Windows
Locate the downloaded Android Studio installation executable file (named
androidstudio-bundle-<version>.exe) in a Windows Explorer window and
double-click on it to start the installation process, clicking the Yes button in the
User Account Control dialog if it appears.
Once the Android Studio setup wizard appears, work through the various screens
to configure the installation to meet your requirements in terms of the file system
location into which Android Studio should be installed and whether or not it
should be made available to other users of the system. When prompted to select
the components to install, make sure that the Android Studio, Android SDK and
Android Virtual Device options are all selected.
Although there are no strict rules on where Android Studio should be installed
on the system, the remainder of this book will assume that the installation was
performed into C:\Program Files\Android\Android Studio and that the Android
SDK packages have been installed into the user’s AppData\Local\Android\sdk
subfolder. Once the options have been configured, click on the Install button to
begin the installation process.
On versions of Windows with a Start menu, the newly installed Android Studio
can be launched from the entry added to that menu during the installation. The
executable may be pinned to the task bar for easy access by navigating to the
Android Studio\bin directory, right-clicking on the executable and selecting the
Pin to Taskbar menu option. Note that the executable is provided in 32-bit
(studio) and 64-bit (studio64) executable versions. If you are running a 32-bit
system be sure to use the studio executable.
2.5.2 Installation on Mac OS X
Android Studio for Mac OS X is downloaded in the form of a disk image (.dmg)
file. Once the androidstudio-ide-<version>.dmg file has been downloaded,
locate it in a Finder window and double-click on it to open it as shown in Figure
2-2:
Figure 2-2
To install the package, simply drag the Android Studio icon and drop it onto the
Applications folder. The Android Studio package will then be installed into the
Applications folder of the system, a process which will typically take a few
minutes to complete.
To launch Android Studio, locate the executable in the Applications folder using
a Finder window and double-click on it. When attempting to launch Android
Studio, an error dialog may appear indicating that the JVM cannot be found. If
this error occurs, it will be necessary to download and install the Mac OS X Java
6 JRE package on the system. This can be downloaded from Apple using the
following link:
http://support.apple.com/kb/DL1572
Once the Java for OS X package has been installed, Android Studio should
launch without any problems.
For future easier access to the tool, drag the Android Studio icon from the Finder
window and drop it onto the dock.
2.5.3 Installation on Linux
Having downloaded the Linux Android Studio package, open a terminal
window, change directory to the location where Android Studio is to be installed
and execute the following command:
unzip <path to package>androidstudio-ide-<version>-linux.zip
Note that the Android Studio bundle will be installed into a subdirectory named
androidstudio. Assuming, therefore, that the above command was executed in
homedemo, the software packages will be unpacked into
homedemo/androidstudio.
To launch Android Studio, open a terminal window, change directory to the
androidstudio/bin subdirectory and execute the following command:
./studio.sh
Immediately after installing Android Studio for the first time it is likely that only
the latest released version of the Android SDK has been installed. To install
preview or older versions of the Android SDK simply select the checkboxes
corresponding to the versions and click on the Apply button.
It is also possible that updates will be listed as being available for the latest
SDK. To access detailed information about the packages that are available for
update, enable the Show Package Details option located in the lower right-hand
corner of the screen. This will display information similar to that shown in
Figure 2-6:
Figure 2-6
The above figure highlights the availability of an update. To install the updates,
enable the checkbox to the left of the item name and click on the Apply button.
In addition to the Android SDK packages, a number of tools are also installed
for building Android applications. To view the currently installed packages and
check for updates, remain within the SDK settings screen and select the SDK
Tools tab as shown in Figure 2-7:
Figure 2-7
Within the Android SDK Tools screen, make sure that the following packages
are listed as Installed in the Status column:
· Android SDK Build-tools
· Android SDK Tools
· Android SDK Platform-tools
· Android Support Repository
· Android Support Library
· Google Repository
· Google USB Driver (Windows only)
· Intel x86 Emulator Accelerator (HAXM installer)
In the event that any of the above packages are listed as Not Installed or
requiring an update, simply select the checkboxes next to those packages and
click on the Apply button to initiate the installation process.
Once the installation is complete, review the package list and make sure that the
selected packages are now listed as Installed in the Status column. If any are
listed as Not installed, make sure they are selected and click on the Install
packages… button again.
An alternative to using the Android SDK settings panel is to access the
Standalone SDK Manager which can be launched using the link in the lower
left-hand corner of the settings screen. The Standalone SDK Manager (Figure 2-
8) provides a similar list of packages together with options to perform update
and installation tasks:
Figure 2-8
The location of the SDK on your system can be identified by launching the
Standalone SDK Manager and referring to the Android SDK Location: field
located at the top of the settings panel as highlighted in Figure 2-9:
Figure 2-9
Once the location of the SDK has been identified, the steps to add this to the
PATH variable are operating system dependent:
2.8.1 Windows 7
1. Right-click on Computer in the desktop start menu and select Properties
from the resulting menu.
2. In the properties panel, select the Advanced System Settings link and, in the
resulting dialog, click on the Environment Variables… button.
3. In the Environment Variables dialog, locate the Path variable in the System
variables list, select it and click on Edit…. Locate the end of the current
variable value string and append the path to the Android platform tools to the
end, using a semicolon to separate the path from the preceding values. For
example, assuming the Android SDK was installed into
C:\Users\demo\AppData\Local\Android\sdk, the following would be
appended to the end of the current Path value:
;C:\Users\demo\AppData\Local\Android\sdk\platform-
tools;C:\Users\demo\AppData\Local\Android\sdk\tools
4. Click on OK in each dialog box and close the system properties control
panel.
Once the above steps are complete, verify that the path is correctly set by
opening a Command Prompt window (Start -> All Programs -> Accessories ->
Command Prompt) and at the prompt enter:
echo %Path%
The returned path variable value should include the paths to the Android SDK
platform tools folders. Verify that the platform-tools value is correct by
attempting to run the adb tool as follows:
adb
The tool should output a list of command line options when executed.
Similarly, check the tools path setting by attempting to launch the Android SDK
Manager:
android
In the event that a message similar to the following message appears for one or
both of the commands, it is most likely that an incorrect path was appended to
the Path environment variable:
'adb' is not recognized as an internal or external command,
operable program or batch file.
The tool should output a list of command line options when executed.
Similarly, check the tools path setting by attempting to launch the Android SDK
Manager:
android
In the event that a message similar to the following message appears for one or
both of the commands, it is most likely that an incorrect path was appended to
the Path environment variable:
'adb' is not recognized as an internal or external command,
operable program or batch file.
2.8.3 Windows 10
Right-click on the Start menu, select System from the resulting menu and click
on the Advanced system settings option in the System window. Follow the steps
outlined for Windows 7 starting from step 2 through to step 4.
2.8.4 Linux
On Linux this will involve once again editing the .bashrc file. Assuming that the
Android SDK bundle package was installed into homedemo/Android/sdk, the
export line in the .bashrc file would now read as follows:
export
PATH=homedemo/java/jdk1.7.0_10/bin:homedemo/Android/sdk/platform-
tools:homedemo/Android/sdk/tools:homedemo/androidstudio/bin:$PATH
Note also that the above command adds the androidstudio/bin directory to the
PATH variable. This will enable the studio.sh script to be executed regardless of
the current directory within a terminal window.
2.8.5 Mac OS X
A number of techniques may be employed to modify the $PATH environment
variable on Mac OS X. Arguably the cleanest method is to add a new file in the
etcpaths.d directory containing the paths to be added to $PATH. Assuming an
Android SDK installation location of Usersdemo/Library/Android/sdk, the path
may be configured by creating a new file named android-sdk in the etcpaths.d
directory containing the following lines:
Usersdemo/Library/Android/sdk/tools
Usersdemo/Library/Android/sdk/platform-tools
Note that since this is a system directory it will be necessary to use the sudo
command when creating the file. For example:
sudo vi etcpaths.d/android-sdk
Once this window appears, Android Studio is ready for a new project to be
created. To create the new project, simply click on the Start a new Android
Studio project option to display the first screen of the New Project wizard as
shown in Figure 3-2:
Figure 3-2
If you do not have a domain name you can enter any other string into the
Company Domain field, or you may use ebookfrenzy.com for the purposes of
testing, though this will need to be changed before an application can be
published:
com.ebookfrenzy.androidsample
The Project location setting will default to a location in the folder named
AndroidStudioProjects located in your home directory and may be changed by
clicking on the button to the right of the text field containing the current path
setting.
Click Next to proceed. On the form factors screen, enable the Phone and Tablet
option and set the minimum SDK setting to API 14: Android 4.0
(IceCreamSandwich). The reason for selecting an older SDK release is that this
ensures that the finished application will be able to run on the widest possible
range of Android devices. The higher the minimum SDK selection, the more the
application will be restricted to newer Android devices. A useful chart (Figure 3-
3) can be viewed by clicking on the Help me choose link. This outlines the
various SDK versions and API levels available for use and the percentage of
Android devices in the marketplace on which the application will run if that
SDK is used as the minimum level. In general it should only be necessary to
select a more recent SDK when that release contains a specific feature that is
required for your application.
To help in the decision process, selecting an API level from the chart will
display the features that are supported at that level.
Figure 3-3
Since the project is not intended for Google TV, Android Auto or wearable
devices, leave the remaining options disabled before clicking Next.
3.3 Creating an Activity
The next step is to define the type of initial activity that is to be created for the
Random documents with unrelated
content Scribd suggests to you:
—Du veau! du veau!... Viande peu mûre, viande creuse...
Donnez-moi l’étole.
Il se croisa l’étole sur la poitrine et murmura quelques mots
latins.
—Avez-vous songé aux hors-d’œuvre? reprit-il gravement.
—Oui, monsieur le doyen: il y a un dindon à la broche.
—Comment, un dindon pour hors-d’œuvre! Êtes vous fou, par
exemple!
—Il est fort beau, il pèse douze livres.
—Vous ne me comprenez pas: je vous demande si vous vous
êtes procuré du beurre frais, des olives, du saucisson, du thon
mariné, des anchois...
—Non, monsieur le doyen. Mais Jeanneton a fait une croustade
magnifique.
—Quels entremets?
—Avec l’abatis du dindon...
—Ne me parlez plus de votre dindon! interrompit M. Michelin,
dont la gourmandise déçue avait enflé la voix. Venceslas Labinowski,
ce voleur, nous traita mieux l’année passée dans son ermitage, que
vous ne nous traitez dans votre cure. Quelle cuisine, Dieu m’assiste!
quelle cuisine!... Avez-vous pensé aux vins?
Le pauvre desservant, ahuri, balbutia:
—J’ai acheté cinquante litres de vin de Maraussan au frère
Barnabé, de Saint-Michel.
—Du vin quêté aux portes!... Il doit être bon! dit M. Michelin,
haussant les épaules. D’ailleurs, le maraussan est un vin liquoreux,
c’est un vin de dessert, et j’espère que vous n’oserez pas nous le
servir comme ordinaire.
—Mais j’ai du vin rouge du pays de cette année...
—Eh quoi! pas la moindre bouteille de saint-georges ou de
faugères?...
M. Martin, écrasé, ne répondit pas. Il prit sur le vestiaire le
manipule et avec une épingle l’attacha au bras droit du célébrant.
Celui-ci lui lança un regard où l’ironie et le dédain pétillaient
ensemble; puis, avant que le malheureux curé d’Hérépian lui
présentât la chasuble, l’enlevant de ses doigts crispés, il la revêtit
tout d’un coup. Il en nouait vivement les cordons, quand les ermites,
ayant mis quelque ordre parmi l’assistance, qui se bousculait dans la
chapelle trop étroite, étant parvenus surtout à obtenir un peu de
silence, reparurent dans la sacristie. M. le doyen leva la main,
indiquant par un geste à deux de ses vicaires qui venaient
d’endosser l’un la dalmatique de diacre, l’autre celle de sous-diacre,
de se ranger devant lui, et l’on marcha processionnellement vers le
chœur.
«Et moi? et moi? Je n’aurais donc pas la gloire de servir la messe
à M. le doyen?»
Hélas! je venais de recevoir la première grande humiliation de ma
vie. Malgré ma soutanelle rouge qui me seyait si bien, mon surplis
amidonné et raide comme une planche, ma calotte de cardinal, qui
me donnait un petit air de jeune pontife, je n’étais rien, on ne
m’avait pas vu, je n’existais pas.
ebookbell.com