Android SDK Training Notes

Android SDK Training Notes with Eclipse

  • Eclipse
    • Android is an operating system based on Linux
      • designed to be run on mobile devices
      • Android Platform contains application framework for creation of apps
    • Android Architectures – Software Stack
      • base is Linux Kernel – highly optimized for mobile operating systems
        • android runtime and set of libraries then enable behavior of operating system
          • application framework sits on runtime
            • applications are top of software stack
      • Linux Kernel has a set of drivers to interface with onboard devices
      • Android Runtime contains core libraries and Dalvik virtual machine (jvm) replaces conventional java compiler and is super optimized
      • Libraries contain libraries to address features of android
      • Application Framework has modules to control different components of applications
        • including activity managers, location managers, window managers
      • Applications are programs
        • at least home screen, browser, contacts, and phone
        • more and more new apps are included with operating system
        • can add as many apps as memory allows to application layer in stack
      • App Architecture
        • apps are made up of components
          • Activities represent the user interface, the screen itself (represented by java class)
          • Widgets manage display and user interactivity
          • Services perform background jobs (invisible to user)
          • Broadcast receivers react to system messages, from operating system or other apps
      • Component Architecture
        • Each component is implemented as Java class
          • have access to both java classes included in sdk and custom java classes
        • ex. an activity is instance of android.app.Activity
        • button is instance of android.widget.Button
      • Java – compiler uses Android-specific Java implementation
        • primarily Java 5 APIs, with a small amount of Java 6
    • First version released in 9/08
      • had a browser, camera support, search, maps, etc.
    • Creating a Virtual Device
      • From inside Eclipse, select Windows > Android Virtual Device Manager
        • can select from large number of possible devices (top tab), a popular one for testing is Nexus 7
          • select Nexus 7 and hit create AVD
            • fill in parameters, popular target is Android 4.3 JellyBean
            • set Memory Options to 768
            • set SD Card slot to 64MB just in case you want to do card programming for application
            • click OK to create AVD
          • Now select device and click “Start”
        • AMR CPU devices can be slow to run, use Intel Devices for increased responsiveness
          • to get Intel devices, must install more from SDK Manager
            • must get Intel System Images for different packages
            • must get Intel Processor from Extra’s at bottom of page
            • If using newer OS, must get haxm from software.intel.com
          • now install haxm by closing everything and find software in sdk > extras > intel > select executable entitled “intelhaxm-android”
            • doesn’t work on all computers, including mine
              • if it does work, follow same process but use different CPU and check “Use Host GPU” at bottom
    • USB Driver
      • if wanting to test on actual android device, must load Google USB Drivers for Windows
        • visit developer.android.com/sdk/win-usb.html
      • USB drivers vary for different phones, best to contact manufacturers customer service or download drivers from website
    • Setting Device
      • Once phone is connected and there are no flags in device manager, open eclipse > Window > Other > Device to open a panel at the bottom of eclipse with your device listed
    • New Project
      • Once devices are created, go to File > New Project to create a new project and set parameters
        • Android Application > Take most defaults and follow directions on how to define parameters
        • Once created, go to Run > Run to run your project on the device of your choice
    • Directory Structure
      • First Folder in Project Explorer panel is src folder contains Java code
        • one package contains classes which represent apps activities
          • this package is registered in manifest ID
        • gen folder is all classes automatically generated
          • one important is R class
        • SDK folder points to jar file which is a part of SDK install
          • notice API versions
          • can change API versions by changing target SDK
            • Project > Project Properties > Android and choose Android Version then Project > Clean and wait a few moments, will change Android version
        • Android Private Library contains android support library, to emulate modern features on older devices
          • automatically installed in newer version of Eclipse
        • Assets folder contains anything that doesn’t need to be directly addressable as java objects
          • not like RES folder, which contains java objects
        • bin directory is managed for you, includes compiled class files and other critical resources, don’t touch this directly
          • if see something suspicious, clean project and see if it is removed
        • libs directory is great place to add java libraries
          • comes with support library
          • also good for 3rd party libraries, but not added to projects class file automatically, must do that ourselves
        • res contains files that define appearance and behavior
          • graphics go in drawable folders
          • layout, menu, and values contains xml files that declare behaviors
          • anim is animation resource
          • color is predefined colors
        • AndroidManifest.xml creates graphical UI that allows changes to be made to app behavior
  • Manifest – AndroidManifest.xml is xml file the describes capabilities of app to device
    • open into a graphical UI
      • choose final tab on bottom of view to open file in XML
        • manifest creates a XML prefix in line 2
        • package name must be unique and correspond with file in src folder
        • versionCode is integer that must be increased each time app is updated on app store
        • versionName can handle other info
        • uses-sdk
          • can set maxSdkVersion if want to compile on one version but allow for use on other
        • application
          • points to resources and properties
            • icon points to icon creative
            • label describes how app will be represented in start screen and application list
              • to jump to resource, hold CTRL + click on resource to open XML file in which resource is defined
            • theme points to applications theme and styling
          • Activity Elements
            • each screen in application is activity
            • each activity must be registered with application manifest file
            • name is fully qualified name of activity, and must match name of com package
              • can also use “.” for placeholder for current package
            • label points to app name
          • intent-filter tells OS when user starts up app, this activity should start first.
    • API Docs
      • go to developers.android.com
        • click on develope
          • choose between training, API guides, and reference
      • documentation is also available thru Eclipse
        • highlight property in question and click help > dynamic help
    • Layouts
      • to edit layouts, must find MainActivity.xml
        • edit onCreate
      • to create new layout, go to res folder on left, expand and select layouts, then right-click and select New > Android XML File
        • can chose variety of types, give new file a name (lowercase, no spec chars)
        • then indicate root element
          • in default layout, relative is used
    • Views and Groups
      • XML layout files describe appearance of android screen
        • visual widgets are java views or instances of view class
          • view class is android.view.View
            • textview is android.widget.TextView
              • button is android.widget.button
                • compound button is android.widget.CompoundButton
            • view group is android.widget.ViewGroup
              • ViewGroups are layout containers
                • linearLayout lays child objects horiz. and vertically
                • RelativeLayout lays out child objects relative to self or other child objects
                • GridView creates 2D Scrollable grid
                • ListView creates a vertical list of scrollable items
                • AbsoluteLayout, DrawerLayout, ViewPager, and many others
              • Mostly want to use linear and relative layouts
    • Dimensions
      • dimensions are units of measurement to control placement and size of visual objects
        • used for placements and size of all visual components
      • these are set in XML layout files or programmatically
      • they can also be set at java runtime
      • Device-Independent Pixels (dp) – Important
        • devices greatly vary, so dp is used to set position and size of containers and allow the device to change the layout but still retain original design
          • alters pixels by ratios
      • Scale-Independent Pixels (sp)
        • use dp for placement of objects, use sp for font size
      • Can also use fixed width measurements, but don’t do this
      • Dimension Resources
        • dimension resource files define reusable dimensions
        • place dimension resource file in res/values folder
        • default is dimens.xml
          • root element is resources, and child elements are dimen elements
          • can set name to any resource id you want
            • all lower case and use underscore
            • to use dimension resource
              • android.parameter=”@dimen/string_name”
                • ex. android:paddingBottom=”@dimen/activity_vertical_margin”
                • where: <dimen name=”activity_vertical_margin”>16dp</dimen> is contained in dimens XML file
      • Managing Multiple Screens can be complex
        • create default dimensions XML file in res/values
        • then set alternative settings for different sizes and orientations
        • in project explorer
          • values folder has default dimensions
          • values-sw600dp folder holds dimens for screen where, if held on long rectangle, the short size has value >= 600dp
            • same for 720dp, -land is if screen is held in landscape orientation
        • can set dimensions in code
          • each view or widget has layoutParams object
          • can set height, width, etc. as properties of layoutParams
    • Linear Layout
      • adds content in linear fashion, one element after another
      • in XML view, can see that objects are added with separate id instances
        • android:id=”@+id/button1”
          • @+id is add a unique identifier
          • within layout file, each object should have it’s own id
  • Debugging
    • if android debug bridge (adb) is used to run apps on emulators and devices
      • gets messages and can even receive custom message
      • always approve logcat view
      • logcat view shows series of messages
        • tag indicates source of message
          • android runtime and dalvik are system level
          • activity level is application level
      • because mistakes can be made when debugging and naming strings, refactoring can be used to minimize the opportunity for typographical errors
        • select entire string and right click > refactor > extract constant
          • call it whatever you want, all caps
      • comment out log calls when ready for deployment as they are not automatically removed
    • toast messages are simple visual messages that appears momentarily on screen
      • managed by the application framework, but triggered by developer
    • Breakpoints allow one to watch the values of variables
    • Dalvik Debug Monitor Service is one of most valuable tools for troubleshooting runtime
      • also called DDMS
      • to work with DDMS, chose device in devices view
        • can take snapshot of screen in DDMS view by clicking snapshot in devices panel
        • can also check memory usage
          • select application in list and toggle update heap button in devices panel
            • in ddms panel, select heap tab and Cause GC to cause garbage collection
              • can then click on that event and look at details about how app is using memory at runtime
        • can also see what is happening in devices persistent storage in file explorer tab
          • shows data storage for app and runtime
            • if device isn’t rooted, or without root permission access, data folder is empty
            • if device is rooted or emulator, you get to see subfolders and can see what is happening in data storage
        • Emulator control allows sending of data to emulator
        • System info show data about processes and applications
    • Once you have more than a single activity, must define how to move between them
      • this is done with intent
        • two kinds, explicit and implicit
          • explicit intent say that wants to use specific activity
          • implicit allows application framework to decide which intent to use
    • current spec says we are supposed to let app handle its own navigation
      • on secondary page, launcher icon should become up button
    • Activity Lifecycle
      • set of stages as they appear and disappear onscreen
      • grouped into tasks
      • when first opened
        • launch activity is invoked (act. 1)
        • this activity is part of task
        • if this activity then launches act 2, it moves to top of stack and act. 1 moves down
          • called going to backstack
        • if back button is then pressed, or 2nd activity is finished, then 2nd act is removed and act. 1 comes to foreground
        • when user hits home button and opens another application, second task is created, with it’s own activities
          • user can switch between tasks from launcher screen or screen that lists all open tasks
            • all activities are available if memory allows, but if not the OS can remove activities
      • Activity Stack rules
        • on single device, only one active activity at any time
          • if screen is in fragment view, many can be shown but only one is fully active
        • one activity can be last active
        • other activities are queued as previous activities
          • can have as many in the backstack as necessary
        • Activity can be in one of many states
          • active/resumed – top of stack, visible and interactive
          • paused – can be visible but without focus
          • stopped – not visible, but not removed from memory
          • inactive – completely removed from stack
      • Lifecycle
        • as activity comes to screen, it is created
          • onCreate()
        • then it is started
          • onStart()
        • then is is resumed, where it is visible and interactive
          • onResume()
        • as app is shut down, it goes into pause
          • onPause()
        • then it is stopped if it is to become invisible
          • onStop()
        • if removed from memory, then destroyed
          • onDestroy()
        • interesting event paths
          • if in stop state and want to get to resume
            • onRestart() to onStart() then to onResume()
          • if paused, and want to get to resume
            • onResume() event
      • Loading and activity layout
        • each lifecycle event is associated with a method
          • example is onCreate() method
            • setContentView loads layout
    • Each event that is triggered as move from activity to activity is associated with a method that are named for the event
      • default version of methods are located in activity class or super class
        • to add own code, must override methods
        • brand new projects already have onCreate() method
  • Device Market Fragmentation
    • important to understand distribution of operating systems
    • Biggest issue you have to deal with is screen sizes and pixel densities
      • use dp and sp and create images with different sizes and resolutions for use with different pixel densities
      • resizing images
        • in res folder, notice multiple drawable folders (images folders) that map to different pixel densities
          • mdpi – medium pixel density per inch
          • xhdpi – high density
          • xxhdpi – extra high
        • graphic creation can be cumbersome in graphical application.
        • there is an app called 9patch-resizer that does work for you
          • code.google.com/p.9patch-resizer/
          • this will allow you add drag images designed for certain pixel density
            • ldpi (low) ~120dpi
            • mdpi (medium) ~160dpi
            • hdpi (high) ~240dpi
            • xhdpi (extra-high) ~320dpi
            • xxhdpi (extra-extra-high) ~480dpi
            • xxxhdpi (extra-extra-extra-high) ~640dpi
          • creates folders for each file in original folder, just copy and paste to res folder in Eclipse Project Explorer
            • doesn’t remove anything currently there, just adds new files
      • rather than always creating multiple versions of graphics, will sometimes want to stretch graphic to screen sizes
      • Launcher icons identify app on screen
  • User Interface
    • can control with widgets in layouts in layout file
    • use styles to control appearance across multiple objects
      • styles are set in XML files and applied, once defined can be reused
        • beginning styles file is in values folder
    • themes
      • default is holo light with dark action bar
      • can update theme in activity manifest.xml on android:theme line
        • use this syntax: android:theme=”@android:style/Theme.Black.NoTitleBar”
    • Scrolling
      • common issue is that sometimes there is too much content to fit on screen and user must be able to scroll text
        • wrap content in scrolling container called scrollView
    • Fragments
      • in Honeycomb, fragments API gave more flexibility in laying out screen
        • instead of one layout per screen, can use multiple layouts and be flexible on how they are laid out
      • use eclipse android dev tools template to build adaptable application with fragments
        • when creating new project, follow screens like normal but when getting to create activity screen, use master detail/flow
          • has a list and a detail fragment
            • on cell phone, start with list and then detail if item in list is selected while list goes away
            • on tablet, two fragments are displayed side by side
  • IMPORTANT TIP – on emulator, use CTRL + F12 to switch orientation of emulator display from portrait to landscape
  • Events
    • event handlers can be placed as attributes on widgets in layouts
      • and example is a button which, when pressed, gives this code:
        • android:onClick=”gotoActivity”
          • android:onClick is event handler
          • gotoActivity is method for event that is described in main activity java file
      • can also make event handlers purely in java without event handlers in xml file
        • more code but advantage is that everything is contained in one java file
      • Handling system level events
        • used with class called broadcast receiver
          • 3 main steps
            • 1 – Grant permission to application to deal with system level info
            • 2 – create java class
            • 3 – register java class
      • Orientation Changes
        • when orientation changes, activity is destroyed and rebuilt from scratch on system
        • many times, the OS can handle this change, however, sometimes will need to be personally tweaked to work correctly
          • can control orientation change, by
            • tell app in manifest that you don’t want automatic recreation
            • add event handler in code
  • Options Menu
    • menu that appears when options icon is touched
      • position differs depending on device
      • can be defined in XML or java code
      • can define actions for application without taking up screen real estate
  • Action bar
    • introduced in Honeycomb and later device
    • consists of area at top of screen with launcher icon, application name, and options menu if it exists
    • we can add buttons to action bar by moving them from menu and placing them
      • add this to each item in menu
        • android:showAsAction=”always”
          • different options for actions, use them wisely
    • can also add items to action bar at runtime
      • every activity already has options menu, but is empty by default
    • best practice is to define menu items in resources XML file, then use programming one activities where that menu item might be necessary
  • Intent Extras
    • as we move to more complex activities, will need to send and receive data between activities
    • this is done with intent extras
    • when returned to calling activity, these are called results
      • in order to get information into activity, you must tell it you want that information in the first place
        • do that with startActivityForResult
    • Data lists
      • as the data sent and returned becomes greater and greater, lists are a great way to organize information
      • working with persistent data is critical, check out android sdk local data storage
  • Next Steps
    • learn more about android
      • if I have question, always start with documentation, offline or online
    • follow developer team blog
      • android-developers.blogspot.com
    • Ask Stack Overflow for tech support for android developers
      • stackoverflow.com
    • learn more XML integration with Java
    • foundations of programming, object oriented design
      • oop theory and practice