Xamarin Mobile Development for Android Cookbook

Xamarin Mobile Development for Android Cookbook

By : Matthew Leibowitz

Buy this Book

Xamarin Mobile Development for Android Cookbook

By: Matthew Leibowitz

Buy this Book

Overview of this book

Xamarin is used by developers to write native iOS, Android, and Windows apps with native user interfaces and share code across multiple platforms not just on mobile devices, but on Windows, Mac OS X, and Linux. Developing apps with Xamarin.Android allows you to use and re-use your code and your skills on different platforms, making you more productive in any development. Although it’s not a write-once-run-anywhere framework, Xamarin provides native platform integration and optimizations. There is no middleware; Xamarin.Android talks directly to the system, taking your C# and F# code directly to the low levels. This book will provide you with the necessary knowledge and skills to be part of the mobile development era using C#. Covering a wide range of recipes such as creating a simple application and using device features effectively, it will be your companion to the complete application development cycle. Starting with installing the necessary tools, you will be guided on everything you need to develop an application ready to be deployed. You will learn the best practices for interacting with the device hardware, such as GPS, NFC, and Bluetooth. Furthermore, you will be able to manage multimedia resources such as photos and videos captured with the device camera, and so much more! By the end of this book, you will be able to create Android apps as a result of learning and implementing pro-level practices, techniques, and solutions. This book will ascertain a seamless and successful app building experience.

Xamarin Mobile Development for Android Cookbook

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Working with Xamarin.Android

Introduction

Creating Xamarin.Android projects

Creating user interface layouts

Creating an options menu

Supporting previous Android versions

Adding an action bar

Navigating with the action bar

Adding action bar action items

Creating contextual action mode menu

Creating contextual action mode menus

Sharing code with other platforms

Showing Views and Handling Fragments

Introduction

Using custom views with layouts

Creating and using fragments

Preserving view and fragment state

Navigating between fragments

Fragments and the action bar

Animating fragment navigation

Animating view and object properties

Animating views on the UI

Adding a navigation drawer with fragments

Applying local styles and global themes

Managing App Data

Introduction

Storing data with SharedPreferences

Using files and the filesystem

Reading bundled assets and resources

Parsing, processing, and generating XML

Accessing data with ADO.NET

Accessing data with SQLite.NET

Encrypting databases with SQLCipher

Consuming content providers

Creating content providers

Backing up preferences and files to the cloud

Backing up data to the cloud

Presenting App Data

Introduction

Implementing a ListView

Using a SimpleAdapter

Using custom ListView items

Using a BaseAdapter with arbitrary data

Using a CursorAdapter

Optimizing the ListView

Enabling fast scrolling

Using section indexes

Integrating app searchability

Communicating with the Outside World

Introduction

Consuming REST services with HttpClient

Obtaining a network state

Handling network state changes

Using DownloadManager

Accessing Bluetooth

Transferring data via Bluetooth

Receiving NFC events

Writing NFC tags

Transferring data via NFC

Obtaining location coordinates and addresses

Using Background Tasks

Handling simultaneous service requests

Starting services automatically

Communicating with running services

Notifying Users

Toasts

Embedded alert fragments

Selection alerts

The notification builder

Ongoing notifications

Custom notification views

Push notifications

Interacting with Other Apps

Introduction

Starting app components

Launching other apps

Obtaining data from activities

Using BroadcastReceivers

Scheduling tasks

Making phone calls

Intercepting phone calls

Sending SMS messages

Receiving SMS messages

Presenting Multimedia

Introduction

Playing audio

Playing audio in the background

Managing the audio volume

Recording an audio

Playing a video

Custom video controls

Using the camera

Creating a camera app

Handling high-resolution images

Drawing on the canvas of a View

Drawing on the canvas of a SurfaceView

Responding to the User

Introduction

Responding to simple touches

Responding to scroll gestures

Responding to manipulation gestures

Detecting rotate gestures

Responding to custom user gestures

Listening to sensor data

Listening for sensor triggers

Discovering the environment

Detecting device shakes

Connecting to Wearables

Introduction

Introducing wearable notifications

Customizing wearable notifications

Creating wearable apps

Creating always-on wearable apps

Creating dynamic always-on wearable apps

Communicating with wearables

Building watch faces

Configuring watch faces

Adding In-App Billing

Introduction

Preparing for in-app billing

Integrating in-app billing

Listing available products

Purchasing products

Listing purchased products

Consuming purchases

Publishing Apps

Introduction

Protecting the content

Protecting the code

Preparing the app package

Shrinking the app package

Creating the app package

Uploading the app package

Adding preview testers

Releasing for production

Updating the app

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Building watch faces

Android wearables are far more than just watches, but they still need to perform the basic task of presenting the user with the current time.

Getting ready

Although, automatically installed when creating a new Android Wear project, we do need to have the Xamarin.Android.Wear NuGet installed in the wearable project.

How to do it...

Creating a watch face consists of creating two parts. The first is the rendering engine, which inherits from one of the WatchFaceService.Engine types, and the other is WatchFaceService, which manages it:

We need to specify the permissions for both the handheld and wearable apps. The handheld does not require any activities, but just requires the permissions to be set:
```
[assembly: UsesPermission(Manifest.Permission.WakeLock)]
[assembly: UsesPermission(
  "com.google.android.permission.PROVIDE_BACKGROUND")]
```
For our watch face, we use CanvasWatchFaceService.Engine as our base type. In the constructor, we keep a reference to CanvasWatchFaceService because...

Xamarin Mobile Development for Android Cookbook

By : Matthew Leibowitz

Xamarin Mobile Development for Android Cookbook

By: Matthew Leibowitz

Overview of this book

Related Content you might be interested in

Current Title:

Xamarin Mobile Development for Android Cookbook

Android Application Development Cookbook

Xamarin Mobile Application Development for Android

Android 9 Development Cookbook

Building watch faces

Getting ready

How to do it...