Embedded programming using android

Embedded integration using Android Studio

Introduction

In the following we will guide you through creating a simple Android application with embedding Sygic navigation engine through window in window style.
In this example we will develop a simple application, where you can type in an address string and through a custom button you can start navigation to that address.
You can download the complete demo source code from github.

Create new project

Let’s start Android Studio and start the new project through Start a new Android Studio project, name the application e.g. MyApp, and name the package e.g. com.sygic.example.hello3dwiw. Let’s define the minimum SDK version API 19, and let’s select the template Empty Activity.
The project is automatically populated with activity class and its layout file.

Adapt gradle files

app build gradle

project build gradle

Modify AndroidManifest.xml

The following modifications may be needed:

• add tools:replace=»android:icon, label, theme» into application section to resolve manifest merging conflicts
• add android:configChanges=»orientation|keyboardHidden|screenSize» into activity section to disable re-creating the activity when screen orientation is changed
• add intent filter for com.sygic.aura to handle Custom URL intents

The AndroidManifest.xml could look as follows:

Define graphical look

As an example of the window-in-window look we can prepare the layout in such a way, that it splits the screen into 2 segments:

1. EditText for address input + Button to trigger navigation
2. FrameLayout where we will place Sygic navigation as a fragment.

For source code, see activity_main.xml layout in github demo.

Code the application

Create Sygic Navigation fragment

Create fragment class inheritted from SygicFragment or SygicFragmentSupportV4 . Minimal code should be as follows:

Handle Sygic navigation callbacks

The implementation of the callback class is neccessary if we want to react on some navigation events. Inherit your callback from the Sygic IAPiCallback class. onEvent method is triggered is triggered when various events occured in the navigation, e.g: application start/exit, route computed, destination reached etc.

The example here shows the navigation exit event is captured, on which we close the whole application.

Attention
You should also handle ApiEvents.EVENT_APP_STARTED event, since it is not allowed to call any API function before this event occurs. If any API function is invoked before ApiEvents.EVENT_APP_STARTED or after ApiEvents.EVENT_APP_EXIT , your app may crash!

Request permissions

Before starting Sygic navigation, you need to have proper permissions. Usually, you don’t need any special permission. You may need WRITE_EXTERNAL_STORAGE if you want to use some specific folder for your resources or maps. You may also need READ_PHONE_STATE permission if you are using IMEI as a device ID. However, in most cases all you need to do is call PermissionsUtils.requestStartupPermissions(this) which will return PackageManager.PERMISSION_GRANTED if you have all required permissions. Otherwise, permission flow is triggered and you need to handle onRequestPermissionsResult callback.

Please note
Some permissions will be requested by Sygic navigation itself during runtime. E.g. ACCESS_FINE_LOCATION permission will be requested when the map is shown, or WRITE_EXTERNAL_STORAGE if user decides to install maps to SD card.

Check the resources

Sygic also needs some resource files to be extracted on the storage. When using embedded-with-res artefact from Maven, you can use ResourceManager to verify the integrity of your resource files and also to update them when needed. You can call ResourceManager.sygicLibDir to get File where resources are stored.

Manual resources handling

If you are not using embedded-with-res artefact from Maven, you cannot use ResourceManager to handle lib resources, therefore you need to handle them by yourself. The SygicLib folder needs to be copied to an appropriate location. See the following guidelines:

for Android 10 and higher
The placement of the resources must be the application specific folder:

For Android 9 and below
The placement of the resource folder can be at the root of the device, i.e. sdcard

Sygic navigation will search for the SygicLib folder to read resources.
Since the Sygic version 20.0.0 the SygicLib folder will be moved into the application specific folder with the first application start after installation.

Attention
It is important that the resources are aligned with the library version. Therefore it is required that the resources and library are taken from the same release package.

Start Sygic navigation and call the API function

To start the navigation, simply display Sygic navigation fragment that we created before.
Clicking btnNavigate button will trigger Sygic API function ApiNavigation.navigateToAddress . Since all Sygic API calls are blocking, we call it in separate thread. For more robust solution, consider using HandlerThread or coroutines, but avoid doing simultanous API calls from multiple threads, since Sygic API is not thread safe.

Attention
For simplicity, this demo is not checking if ApiEvents.EVENT_APP_STARTED was triggered and therefore it could possibly crash on ApiNavigation.navigateToAddress call in some cases.

Build and test application

Run the application. At first start, resources will be extracted and maybe some permissions will be requested. To get into the map, you will also need a license.

If you run into some issues, please check also FAQ.

Running the application should yield the following outcome.

Источник

Embedded programming using android

ZXing Android Embedded

Barcode scanning library for Android, using ZXing for decoding.

The project is loosely based on the ZXing Android Barcode Scanner application, but is not affiliated with the official ZXing project.

1. Can be used via Intents (little code required).
2. Can be embedded in an Activity, for advanced customization of UI and logic.
3. Scanning can be performed in landscape or portrait mode.
4. Camera is managed in a background thread, for fast startup time.

A sample application is available in Releases.

By default, Android SDK 24+ is required because of zxing:core 3.4.x. SDK 19+ is supported with additional configuration, see Older SDK versions.

Adding aar dependency with Gradle

Add the following to your build.gradle file:

Older SDK versions

By default, only SDK 24+ will work, even though the library specifies 19 as the minimum version.

For SDK versions 19+, one of the changes changes below are required. Some older SDK versions below 19 may work, but this is not tested or supported.

Option 1. Downgrade zxing:core to 3.3.0

Option 2: Desugaring (Advanced)

This option does not require changing library versions, but may complicate the build process.

This requires Android Gradle Plugin version 4.0.0 or later.

Example for SDK 21+:

SDK 19+ additionally requires multiDex. In addition to these gradle config changes, the Application class must also be changed. See for details: Configure your app for multidex.

Hardware acceleration is required since TextureView is used.

Make sure it is enabled in your manifest file:

Usage with ScanContract

Note: startActivityForResult is deprecated, so this example uses registerForActivityResult instead. See for details: https://developer.android.com/training/basics/intents/result

startActivityForResult can still be used via IntentIntegrator , but that is not recommended anymore.

See BarcodeOptions for more options.

Generate Barcode example

While this is not the primary purpose of this library, it does include basic support for generating some barcode types:

Changing the orientation

To change the orientation, specify the orientation in your AndroidManifest.xml and let the ManifestMerger to update the Activity’s definition.

Customization and advanced options

For more advanced options, look at the Sample Application, and browse the source code of the library.

This is considered advanced usage, and is not well-documented or supported.

The camera permission is required for barcode scanning to function. It is automatically included as part of the library. On Android 6 it is requested at runtime when the barcode scanner is first opened.

When using BarcodeView directly (instead of via IntentIntegrator / CaptureActivity), you have to request the permission manually before calling BarcodeView#resume() , otherwise the camera will fail to open.

To deploy the artifacts the your local Maven repository:

You can then use your local version by specifying in your build.gradle file:

JourneyApps — Creating business solutions with mobile apps. Fast.

Источник

Embedded Programming with Android: Bringing Up an Android System from Scratch

Explore a preview version of Embedded Programming with Android: Bringing Up an Android System from Scratch right now.

O’Reilly members get unlimited access to live online training experiences, plus books, videos, and digital content from 200+ publishers.

Book description

The First Practical, Hands-On Guide to Embedded System Programming for Android

Today, embedded systems programming is a more valuable discipline than ever, driven by fast-growing, new fields such as wearable technology and the Internet of Things. In this concise guide, Roger Ye teaches all the skills you’ll need to write the efficient embedded code necessary to make tomorrow’s Android devices work.

The first title in Addison-Wesley’s new Android™ Deep Dive series for intermediate and expert Android developers, Embedded Programming with Android™ draws on Roger Ye’s extensive experience with advanced projects in telecommunications and mobile devices. Step by step, he guides you through building a system with all the key components Android hardware developers must deliver to manufacturing. By the time you’re done, you’ll have the key programming, compiler, and debugging skills you’ll need for real-world projects.

First, Ye introduces the essentials of bare-metal programming: creating assembly language code that runs directly on hardware. Then, building on this knowledge, he shows how to use C to create hardware interfaces for booting a Linux kernel with the popular U-Boot bootloader. Finally, he walks you through using filesystem images to boot Android and learning to build customized ROMs to support any new Android device. Throughout, Ye provides extensive downloadable code you can run, explore, and adapt.

Build a complete virtualized environment for embedded development

Understand the workflow of a modern embedded systems project

Develop assembly programs, create binary images, and load and run them in the Android emulator

Learn what it takes to bring up a bootloader and operating system

Move from assembler to C, and explore Android’s goldfish hardware interfaces

Program serial ports, interrupt controllers, real time clocks, and NAND flash controllers

Integrate C runtime libraries

Support exception handling and timing

Use U-Boot to boot the kernel via NOR or NAND flash processes

Gain in-depth knowledge for porting U-Boot to new environments

Integrate U-Boot and a Linux kernel into an AOSP and CyanogenMod source tree

Create your own Android ROM on a virtual Android device

Источник

Embedded Programming with Android: Bringing Up an Android System from Scratch

• Sorry, this book is no longer in print.

eBook (Watermarked)

• Your Price: $25.59
• List Price: $31.99
• Includes EPUB, MOBI, and PDF
• About eBook Formats

This eBook includes the following formats, accessible from your Account page after purchase:

EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

PDF The popular standard, used most often with the free Adobe® Reader® software.

This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

About

Features

• Gives detailed technical discussion about bare-metal programming
• Uses a live example to teach how to build an Android system from scratch
• Hands-on and project-based
• Uses porting U-Boot to the Android emulator as a real project to illustrate the workflow and the essential knowledge of the embedded system programming

Description

• Copyright 2016
• Dimensions: 7″ x 9″
• Pages: 400
• Edition: 1st

• Book
• ISBN-10: 0-13-403000-1
• ISBN-13: 978-0-13-403000-5

The First Practical, Hands-On Guide to Embedded System Programming for Android

Today, embedded systems programming is a more valuable discipline than ever, driven by fast-growing, new fields such as wearable technology and the Internet of Things. In this concise guide, Roger Ye teaches all the skills you’ll need to write the efficient embedded code necessary to make tomorrow’s Android devices work.

The first title in Addison-Wesley’s new Android™ Deep Dive series for intermediate and expert Android developers, Embedded Programming with Android™ draws on Roger Ye’s extensive experience with advanced projects in telecommunications and mobile devices. Step by step, he guides you through building a system with all the key components Android hardware developers must deliver to manufacturing. By the time you’re done, you’ll have the key programming, compiler, and debugging skills you’ll need for real-world projects.

First, Ye introduces the essentials of bare-metal programming: creating assembly language code that runs directly on hardware. Then, building on this knowledge, he shows how to use C to create hardware interfaces for booting a Linux kernel with the popular U-Boot bootloader. Finally, he walks you through using filesystem images to boot Android and learning to build customized ROMs to support any new Android device. Throughout, Ye provides extensive downloadable code you can run, explore, and adapt.

• Build a complete virtualized environment for embedded development
• Understand the workflow of a modern embedded systems project
• Develop assembly programs, create binary images, and load and run them in the Android emulator
• Learn what it takes to bring up a bootloader and operating system
• Move from assembler to C, and explore Android’s goldfish hardware interfaces
• Program serial ports, interrupt controllers, real time clocks, and NAND flash controllers
• Integrate C runtime libraries
• Support exception handling and timing
• Use U-Boot to boot the kernel via NOR or NAND flash processes
• Gain in-depth knowledge for porting U-Boot to new environments
• Integrate U-Boot and a Linux kernel into an AOSP and CyanogenMod source tree
• Create your own Android ROM on a virtual Android device

Extras

Related Article

Companion Site

Please visit the associated website to download the code for Embedded Programming with Android at here.

Источник