Tech Kaizen: ANDROID DEVELOPMENT

Showing posts with label ANDROID DEVELOPMENT. Show all posts

Digital Audio Programming

Digital Audio is the most commonly used method to represent sound inside a computer. In this method sound is stored as a sequence of samples taken from the audio signal using constant time intervals. The quality of digital audio signal depends on the time (recording rate) and voltage resolution (usually in an linear integer representation with basic unit one bit). A sample represents volume of the signal at the moment when it was measured. In uncompressed digital audio each sample require one or more bytes of storage. Number of bytes required depends on number of channels (mono, stereo) and sample format (8 or 16 bits, mu-Law, etc.). The length of this interval determines the sampling rate. Normally used sampling rates are between 8 kHz (telephone quality) and 48 kHz (DAT tapes).

Digital audio can be stored in a wide range of formats. Generally speaking, audio comes in two flavors: compressed and uncompressed. Compressed audio can further be subdivided into different kinds of compression: lossless, which preserves the original content exactly, and lossy which achieves more compression at the expense of degrading the audio. Uncompressed PCM audio, on the other hand, is defined by two parameters: the sample rate and the bit-depth. Loosely speaking, the sample rate limits the maximum frequency that can be represented by the format, and the bit-depth determines the maximum dynamic range that can be represented by the format. You can think of bit-depth as determining how much noise there is compared to signal.

In the Linux kernel, there have historically been two uniform sound APIs used. One is OSS(Open Sound System); the other is ALSA (Advanced Linux Sound Architecture). ALSA is available for Linux only, and as there is only one implementation of the ALSA interface, ALSA refers equally to that implementation and to the interface itself.

Android Native code makes uses of OpenSL ES (Open Sound Library for Embedded Systems) for handling Audio processing.

ref:

The ABCs of PCM (Uncompressed) digital audio - http://blog.bjornroche.com/2013/05/the-abcs-of-pcm-uncompressed-digital.html

WAVE PCM soundfile format - https://ccrma.stanford.edu/courses/422/projects/WaveFormat/

An introduction to Linux sound systems and APIs - http://archive09.linux.com/articles/113775

A Tutorial on Using the ALSA Audio API - http://equalarea.com/paul/alsa-audio.html

How to write ALSA driver - http://c-qs.blogspot.com/2014/05/writing-of-alsa-driver.html

alsa vs tinyalsa - http://blog.csdn.net/myzhzygh/article/details/8468210

Open Sound System(OSS) -

Advanced Linux Sound Architecture(ALSA) -

ALSA pcm - http://www.alsa-project.org/alsa-doc/alsa-lib/pcm.html
ALSA - alsa-lib, libsound2.so - http://www.alsa-project.org/alsa-doc/alsa-lib/pcm.html
ALSA Pulse Audio - http://freedesktop.org/software/pulseaudio/doxygen/simple.html
Pulse Audio(libpulse.so) - http://freedesktop.org/software/pulseaudio/doxygen/simple.html
Linux sound drivers - http://www.tldp.org/HOWTO/Sound-HOWTO/

Introduction to Audio programming -

How Audio Data is Represented - http://blogs.msdn.com/b/dawate/archive/2009/06/22/intro-to-audio-programming-part-1-how-audio-data-is-represented.aspx
Demystifying the WAV Format - http://blogs.msdn.com/b/dawate/archive/2009/06/23/intro-to-audio-programming-part-2-demystifying-the-wav-format.aspx
An Introduction to Audio Processing Objects - http://msdn.microsoft.com/en-us/magazine/dn201755.aspx
Synthesizing Simple Wave Audio using C# - http://blogs.msdn.com/b/dawate/archive/2009/06/24/intro-to-audio-programming-part-3-synthesizing-simple-wave-audio-using-c.aspx
Algorithms for Different Sound Waves in C# - http://blogs.msdn.com/b/dawate/archive/2009/06/25/intro-to-audio-programming-part-4-algorithms-for-different-sound-waves-in-c.aspx

C/C++ wav processing sample code - https://android.googlesource.com/platform/frameworks/av/+/jb-dev/cmds/stagefright/

Linux pcm audio sample code - http://www.alsa-project.org/alsa-doc/alsa-lib/_2test_2pcm_8c-example.html

Android audio native programming using OpenSL ES - http://audioprograming.wordpress.com/2012/03/03/android-audio-streaming-with-opensl-es-and-the-ndk/

Android API for record/play audio(example: pcm): AudioRecord, AudioTrack -

Chrome Development

Chrome OS is an operating system based on the Linux kernel and designed by Google to work with web applications and installed applications. Initially, Chrome OS was almost a pure web thin client operating system with only a handful of "native" applications, but Google gradually began encouraging developers to create "packaged applications", some of which can work offline.

Chrome OS is built upon the open source project called Chromium OS which, unlike Chrome OS, can be compiled from the downloaded source code.

ref:

Chrome Operating System - http://en.wikipedia.org/wiki/Chrome_OS

Chrome development - https://developer.chrome.com

Google Chromium project - http://www.chromium.org/Home

Google developers - https://developers.google.com/

Developing applications on Chromebook - http://www.chromium.org/chromium-os/developing-apps-on-your-chromium-os-device

Google Chrome platform API - https://developer.chrome.com/home/platform-pillar, https://developer.chrome.com/extensions/api_index

Google Chrome Development guide - https://developer.chrome.com/extensions/devguide

Chromium embedded framework(CEF) - https://code.google.com/p/chromiumembedded/

Reflections on Developing our First Chrome AppReflections on Developing our First Chrome App - https://software.intel.com/en-us/articles/reflections-on-developing-our-first-chrome-app

Chromebooks*: Developing the user experience of the future - https://software.intel.com/en-us/articles/chromebooks-developing-the-user-experience-of-the-future

Essential Resources Guide - https://docs.google.com/document/d/16pGWXaoxC6CtVV1kZ0I9PgtSntZP80_2gWmaxKSLB18/edit#

Android Power Management

Power/energy consumption comes from hardware component utilization in the device. comes from limiting . Also, look carefully at your methods for utilizing hardware components, and make use of the most efficient methods.

The Android framework is designed to be energy efficient. When apps need hardware data or contents, Android provides passive event-driven mechanisms instead of prompting applications to actively poll the data. This is because active polling introduces more or hardware utilization than event driven methods, which suggests we should utilize event driven mechanisms to cache the events in the app. Android provides events like to notify the apps on the changes of hardware components or the changes of contents. Each kind of event is managed by internal services. Once the services detect changes, the services notify the apps.

Suppose we design an app that needs location data. Android provides a location service enabling location data to multiple applications. The service allows the app developer to specify the location provider: . Deciding which provider to use is a trade-off in accuracy, speed and energy efficiency. Once an app registers itself to the location service with specified criteria, the location service sends location change notifications to the app according to the criteria.

(based on the ) give you a way to perform time-based operations outside the lifetime of your application. For example, you could use an alarm to initiate a long-running operation, such as starting a service once a day to download a weather forecast.

Android Suspend:

In android patched kernel, going to request_suspend_state() in kernel/power/earlysuspend.c (since android add the & wakelock feather in kernel). For detail understand that, let first introduce several new feather android imported.

Files:

· linux_source/kernel/power/main.c

· linux_source/kernel/power/earlysuspend.c

· linux_source/kernel/power/wakelock.c

Early Suspend:

Early suspend is a mechanism that android introduced into linux kernel. This state is btween really suspend, and trun off screen. After Screen is off, several device such as , , will stop for battery life and functional requirement.

Late Resume

Late resume is a mechinism pairs to early suspend, executed after the kernel and system resume finished. It will resume the devices suspended during early suspend.

Wake Lock

Wake lock acts as a core member in android power management system. wake lock is a lock can be hold by kernel space ,system servers and applications with or without timeout. In an android patched linux kernel (referenced as android kernel below) will timing how many and how long the lock have. If there isn't any of wake lock prevent suspend(WAKE_LOCK_SUSPEND), android kernel will call linux suspend (pm_suspend()) to let entire system going to suspend.

Suspend vs Hibernate:

Suspend does not turn off your computer. It puts the computer and all peripherals on a low power consumption mode. Suspend saves the state of your computer to RAM. If the battery runs out or the computer turns off for some reason, the current session and unsaved changes will be lost.

Hibernate saves the state of your computer to the hard disk and completely powers off. When resuming, the saved state is restored to RAM.

Linux kernel currently there are three methods of suspending available: suspend to RAM (usually called just suspend), (usually known ashibernate), and (sometimes aptly called suspend to both):

Suspend to RAM method cuts power to most parts of the machine aside from the RAM, which is required to restore the machine's state. Because of the large power savings, it is advisable for laptops to automatically enter this mode when the computer is running on batteries and the lid is closed (or the user is inactive for some time).
Suspend to disk method saves the machine's state into swap space and completely powers off the machine. When the machine is powered on, the state is restored. Until then, there is zero power consumption.
Suspend to both method saves the machine's state into swap space, but does not power off the machine. Instead, it invokes usual suspend to RAM. Therefore, if the battery is not depleted, the system can resume from RAM. If the battery is depleted, the system can be resumed from disk, which is much slower than resuming from RAM, but the machine's state has not been lost.

There are multiple low level interfaces (backends) providing basic functionality, and some high level interfaces providing tweaks to handle problematic hardware drivers/kernel modules (e.g. video card re-initialization).

ref:

Android Power Management -

http://elinux.org/Android_Power_Management

http://www.kandroid.org/online-pdk/guide/power_management.html

http://people.cse.nitc.ac.in/jerrin/files/android_power_management.pdf

http://2013.efyexpo.com/wp-content/uploads/2013/03/_2_Android_Power_Management_EFY.pdf

http://landley.net/kdocs/ols/2012/ols2012-mansoor.pdf

Linux Kernel Power Management -

http://landley.net/kdocs/ols/2003/ols2003-pages-325-339.pdf

http://www.mvista.com/download/Embedded-Linux-power-management-on-Intel-Atom-processor.pdf

http://www.intel.com/content/www/us/en/intelligent-systems/intel-embedded-graphics-drivers/linux-power-mgmt-paper.html

http://www.ruf.rice.edu/~mobile/elec518/lectures/2011-tatepeter.pdf

http://events.linuxfoundation.org/sites/events/files/slides/kernel_PM_plain.pdf

http://www.ti.com/general/docs/lit/getliterature.tsp?baseLiteratureNumber=spry166&fileType=pdf

http://www.free-it.de/archiv/talks_2005/paper-11017/paper-11017.html

http://lwn.net/Articles/505683/

Developing Power Aware Applications on Android - https://software.intel.com/en-us/articles/developing-power-aware-applications-on-android

Advanced Android Power Management and Implementation of Wakelocks - http://www.ktm2m.net/~suhopark/apm2.pdf

Power Management from Linux Kernel to Android - http://www.csie.ntu.edu.tw/~b97080/HW-Review%20%20Reports_20100517/HW-Review%20%20Reports/Report/%5B4%5DPower%20Management%20from%20Linux%20Kernel%20to%20Android.pdf

Handling Screen OFF and Screen ON Intents - http://thinkandroid.wordpress.com/2010/01/24/handling-screen-off-and-screen-on-intents/

Android alarm receivers - http://code.tutsplus.com/tutorials/android-fundamentals-scheduling-recurring-tasks--mobile-5788

Suspend vs Hibernate - https://wiki.archlinux.org/index.php/Suspend_and_Hibernate

Android: detecting charge state - http://aspyct.org/blog/2013/05/16/android-detecting-charge-state/

Changing battery state using adb - http://www.stealthcopter.com/blog/2010/07/changing-the-battery-percentage-in-an-avd-android-virtual-device-emulator

Android PowerManager service - https://android.googlesource.com/platform/frameworks/base/+/84e2756c0f3794c6efe5568a9d09101ba689fb39/services/java/com/android/server/power/PowerManagerService.java

Android Power notifier - https://android.googlesource.com/platform/frameworks/base/+/84e2756c0f3794c6efe5568a9d09101ba689fb39/services/java/com/android/server/power/Notifier.java

Android Device File System Structure

Android Device directory structure is not fixed as in normal Linux but the following are typical:

/system/bin – native utilities
/system/xbin – more native utilities
/system/etc – configuration files
/system/apps – location of apps as apk or odex files
/system/framework – application framework files (jar)
/storage/sdcard – accessible outside of the phone (rw)
/data – applications data (rw)
/proc – proc file system
/sys – sys file system
/proc/crypto – encryption/signing schemes

ref:

Android Kernel vs Linux Kernel - http://www.all-things-android.com/content/android-kernel-versus-linux-kernel

Understanding the Android File Hierarchy - http://www.all-things-android.com/content/understanding-android-file-hierarchy

http://techblogon.com/android-file-system-structure-architecture-layout-details/

Android Development Tips

Note:

All tips/commands are written w.r.t Linux(Ubuntu) OS ...

1. Command to start Android AVD manager from commandline

$ android avd

2. Command to start Android SDK manager from commandline

$ android sdk

3. An android emulator device is always rooted. Remount /system partition on the device

$ adb remount

(or)

$ adb shell

# mount -o rw,remount /system

note:

Android Debug Bridge (adb) is a versatile command line tool that lets you communicate with an emulator instance or connected Android-powered device.

4. To avoid the Out of memory error when trying to copy the any file from host to device(guest) /system/bin, you need to start the emulator manually with a large –partion-size argument:

$ emulator -avd MYNAME -partition-size 300

5. Android Development Tools on host OS(Linux, Windows)

$ monitor => device monitor ( logcat, file_manager, push, pull)

$ lint => static analysis

$ proguard => code obfuscation (makes difficult to reverse engineer)

$ monkey => gui testing tool

6. Build android ANT projects

$ ant debug => debug build & create ,apk file

(This creates your debug .apk file inside the project bin/ directory, named -debug.apk)

$ ant release => release build & create ,apk file

$ ant debug install => debug build & create .apk file and install in the active AVD device

7. Install .apk file on the AVD

$ adb install .apk

$ adb -s emulator-5554 install path/to/your/app.apk

$ adb -d install path/to/your/app.apk

(note: The -d flag specifies that you want to use the attached device (in case you also have an emulator running)

8. ADB commands

To know the android device API version =>

$ adb shell getprop ro.build.version.release

To start a application from commandline =>

$ adb shell am start -n com.google.android.contacts/.ContactsActivity

To terminate the application =>

$ adb shell am kill com.google.android.contacts

$ adb shell am force-stop com.google.android.contacts

To start the android Service =>

$ adb shell am startservice -n packageName/.ServiceClass

9. Debug native code on the emulator (or) device using gdbclient(host), gdbserver(device)

a. First you need to run gdbserver on the device =>

$ gdbserver :5039 /system/bin/executable

(note: The :5039 tells gdbserver to listen on port 5039 on the localhost, which adb bridges from the host to the device. executable represents the command to debug, a common one being runtime -s which starts the entire system all running in a single process.)

b. Launch gdb on the desktop. This can be done easily with the following command in the shell from which you built =>

$ gdbclient executable

ref:

http://www.kandroid.org/online-pdk/guide/debugging_gdb.html

http://omappedia.org/wiki/Android_Debugging

10. Android Source code

a. Android GIT repositories - https://android.googlesource.com/

b. Android HAL - http://source.android.com/devices/reference/files.html

c. Android AOSP bionic source code - https://github.com/android/platform_bionic

d. Download Android AOSP source code - http://source.android.com/source/downloading.html

e. Android source code - https://source.android.com/source/, https://github.com/android/platform_system_core

11. Android sample code

  http://developer.android.com/tools/samples/index.html

  https://developers.arcgis.com/android/sample-code/

  http://androidexample.com/

  http://www.vogella.com/tutorials/AndroidSourceCode/article.html

Android Phone status –

http://www.codeproject.com/Articles/511455/Android-Phone-Status-Sample

http://www.vogella.com/code/de.vogella.android.battery/src/de/vogella/android/battery/MainActivity.html

12. Android Books - https://drive.google.com/folderview?id=0B5BO97vHUkN2ZmV0cE5wMXFabFU&usp=sharing_eid

Linux Device Drivers: Kernel to User Space communication

Inside Kernel space code:

To convert data from User space to Kernel space =>

To send data from Kernel space to User space =>

To read/write data to IO device below Device Driver(Firmware) =>

The file_operations structure is defined in linux/fs.h, and holds pointers to functions defined by the driver that perform various operations on the device. Each field of the structure corresponds to the address of some function defined by the driver to handle a requested operation.

C99 way of assigning to elements of a structure. You should use this syntax in case someone wants to port your driver. It will help with compatibility:

struct file_operations fops = {

.read = device_read,

.write = device_write,

.open = device_open,

.release = device_release

};

debugfs is a special filesystem (technically referred as a kernel space-user-space interface) available in Linux kernel since version 2.6.10-rc3. It is a simple to use RAM-based file system specially designed for debugging purposes. debugfs exists as a simple way for kernel developers to make information available to user space.

Inside User space code:

Open device directly from User space and read/write.

example: open(“/dev/device_name”, O_RDWR);

Shared Memory:

Shared memory in user space => mmap(), munmap()

Shared memory in kernel space => remap_pfn_range()

PCI Device Drivers:

- register a new pci driver
- unregister a new pci driver

- network device drivers
- char device drivers
- block device drivers

- driver initialization entry point
- driver exit entry point

Miscellaneous commands:

=> lists all pci device drivers

=> lists all Loadable kernel modules(LKM)

=> add/remove a kernel module

ref:

User space memory access from Kernel => http://www.ibm.com/developerworks/library/l-kernel-memory-access/

Linux Kernel to User space communication(copy_from-user, copy_to_user) - http://www.makelinux.net/ldd3/chp-3-sect-7

Google Research(papers ...) - http://research.google.com/

Kernel to User space communication - http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-2.html

Use mmap() shared memory instead of copy_to_user => http://www.linuxforums.org/forum/kernel/158548-avoid-memory-copying-between-user-space-kernel-space.html

Debugfs -

Debugfs Sample Code -

Debugging Kernel with debgufs -

Miscellaneous Character Drivers -

Linux Device Driver Overview - http://inbasudhakar.blogspot.com/2011/08/pci-driver-flow.html

Practical and effective sandboxing for non-root users - http://people.csail.mit.edu/nickolai/papers/kim-mbox.pdf

packetdrill: Scriptable Network Stack Testing, from Sockets to Packets - http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/pubs/archive/41316.pdf

http://linuxforthenew.blogspot.com/2013/01/why-doshould-we-use-copyfromuser-or.html

Android Development Overview

Android is a Linux-based operating system designed primarily for touchscreen mobile devices such as smartphones and tablet computers. Initially developed by Android, Inc., which Google backed financially and later bought in 2005, Android was unveiled in 2007 along with the founding of the Open Handset Alliance: a consortium of hardware, software, and telecommunication companies devoted to advancing open standards for mobile devices.

Android software development is the process by which new applications are created for the Android operating system. Applications are usually developed in the Java programming language using the Android Software Development Kit, but other development tools are available.

ref:

Android Wiki -

Android Developer - http://developer.android.com/index.html

Android Source - http://source.android.com/

Android Platform Developer's guide - http://www.kandroid.org/online-pdk/guide/index.html