Programim Mobile Leksion Tema: Programimi Mobile në Java
Programim Mobile
Leksion
Tema: Programimi Mobile në Java
Në këtë leksion.... Familja Java dhe J2ME Konfigurimet CLDC dhe CDC, Paketat
Opsionale Krijimi i aplikacioneve MIDP dhe CDC Shembuj aplikacionesh
Hyrje në familjen Java
J2EE kryesisht shërben për ndërtimin e aplikacioneve enterprise që e vënë theksin në zhvillimin e aplikacioneve server-side dhe për web.
J2SE është e destinuar për ndërtimin e aplikacioneve konvencionalë për kompjuterat desktop.
J2ME është nëngrup i J2SE që shërben për zhvillimin e programeve për pajisjet e ndërfutura që nuk mund të suportojnë implementim të plotë të J2SE.
Java Card ofron një mjedis për zhvillimin e aplikacioneve që ekzekutohen në karta smart.
Për shembull do të ishte jo efiçente që në një makinë desktop të përdorej J2EE e cila përfshin paketa për aplikacione enterprise. Gjithashtu implementimi i plotë i J2SE nuk mund të suportohet nga pajisjet e vogla që kanë më pak burime se një makinë desktop.
Platforma J2ME
J2ME është pjesë e familjes Java e ndërtuar me qëllim që të shërbejë për ndërtimin e aplikacioneve që ekzekutohen në mjedise që punojnë me bateri dhe jo me energji elektrike.
Pajisjet me aftësi të ngjashme grupohen në konfigurime dhe brenda secilit konfigurim krijohen profile për të klasifikuar më tej llojin e pajisjes.
J2ME nuk është gjuhë e re por është një version i përshtatur i Java për pajisjet e vogla duke hequr nga J2SE ato pjesë që nuk mund të suportohen. Megjithatë platforma J2ME mund të ekzekutohet në një larmi pajisjesh si TV, PDA, libra elektronikë, telefona etj.
Për momentin në platformën J2ME ekzistojnë dy konfigurime: CLDC(Connected Limited Device Configuration), për
pajisje me Ndërfaqe përdoruesi shumë të thjeshtë Kujtesë të vogël (160Kb deri në 512 Kb) Komunikim wireless Procesor 16 ose 32 bit Energji e kufizuar, zakonisht me bateri Shembuj: telefonat celularë, librat elektronikë, PDA të
thjeshta etj. Këtyre pajisjeve do i referohemi si pajisje më pak të afta.
CDC(Connected Device Configuration), për pajisje me
Ndërfaqe përdoruesi më të larmishme
Kujtesë nga 2 – 16 M. Lidhje me disa tipe rrjetash. Procesorë 16 ose 32 bit. Shembuj: Tv, PDA etj.
Këtyre pajisjeve do i referohemi si pajisje më shumë të afta.
Pajisjet më pak të afta: Konfigurimi CLDC Për momentin ekzistojnë dy versione CLDC: CLDC 1.0 i cili është lëshimi i parë i specifikimit CLDC. CLDC 1.1 i cili është version i përmirësuar i 1.0. CLDC ofron një mjedis ekzekutimi Java (JRE) bazë, por
grupi i klasave bazë zakonisht është i vogël dhe ka nevojë që të përmirësohet nga klasa shtesë. Në fakt CLDC nuk ka ndonjë API të integruar për menaxhimin e ndërfaqes me përdoruesin, nuk implementon ndonjë model I/O dhe ka mangësi në arritjen e sigurisë.
MIDP (Mobile Information Device Profile) Profili MIDP i shtohet konfigurimit CLDC për të mbushur
funksionalitetet që mungojnë. MIDP në fakt është një grup API-sh dhe librarish që ofrojnë funksionalitete si ndërfaqe përdoruesi, lidhje në rrjet, ruajtje të dhënash etj. Aktualisht ekzistojnë dy versione MIDP të cilët implementohen në pajisje reale:
MIDP 1.0 është lëshimi i parë i profilit dhe përfshin ndërfaqe përdoruesi (nivel jo i avancuar) e siguri në rrjet.
MIDP 2.0 ka përshtatshmëri kthimi me MIDP 1.0 dhe ka funksione shtesë si ndërfaqe më të avancuar. Multimedia, lojëra etj.
Aktualisht është specifikuar edhe gjenerata e tretë e MIDP me emrin JSR271.
Ky specifikim bazohet në MIDP 2.0 dhe ka përshtatshmëri kthimi me të. Një aplikacion që zhvillohet sipas profilit MIDP quhet MIDlet.
Këto lloj aplikacionesh nuk përdorin një metodë statike main për pikë hyrëse sikurse ndodh në aplikacionet tradicionalë desktop.
Pika hyrëse e një aplikacioni MIDlet është një klasë që trashëgon nga java.microedition.midlet.MIDlet. Klasa MIDlet ka të përcaktuara disa metoda abstrakte që thirren kur gjendja e MIDlet-it ndryshon.
Një ose më shumë MIDlet-e së bashku me të gjithë skedarët dhe klasat e tjera që i duhen aplikacionit paketohen në një suitë MIDlet. Një suitë MIDlet përbëhet nga një skedar JAR dhe një skedar JAD. Skedari JAR është skedari që duhet të dërgohet në telefon për të instaluar aplikacionin. CDC është plotësisht i përshtatshëm me CLDC.
Metoda Përshkrimi
startApp() Thirret nga AMS kur MIDlet fillon të ekzekutohet nga e para ose kur rimëkëmbet nganjë gjendje e pezulluar.
destroyApp() Thirret nga AMS kur MIDlet përfundon.
pauseApp() Thirret nga AMS kur MIDlet pezullohet
notifyDestroyed() Thirret nga MIDlet. I kërkon AMS që ta shkatërrojë vetë MIDlet-in.
notifyPaused() Thirret nga MIDlet. I kërkon AMS që ta pezullojë vetë MIDlet-in.
resumeRequest() Thirret nga MIDlet-i i pezulluar(p.sh nga një thred në background). I tregon AMS seMIDlet-i do të dalë nga gjendja e pezulluar dhe të bëhet sërish aktiv.
Tabelë 1- Metodat e ciklit jetësor të MIDlet
Suporti për rrjetat
J2ME ofron ndërfaqe rrjeti për zhvillimin e aplikacioneve wireless dhe shfrytëzon aftësitë e këtyre pajisjeve për tu lidhur në rrjet sipas teknologjive të ndryshme të rrjetit wireless. Suporti për lidhjen e pajisjeve në rrjet kryhet nga GCF hierarkia e së cilës tregohet në Figurë
Qëllimi kryesor i GCF është që të përcaktojë një arkitekturë rrjeti sa më të përgjithshme dhe të lejojë akses për tiparet që lidhen me protokollet. GCF i ofron përdoruesit një grup të vetëm abstragimesh për të menaxhuar disa protokolle. GCF përdoret edhe nga CLDC edhe nga CDC por ka disa ndryshime në protokollet që suportojnë. Disa nga llojet e lidhjeve që mund të krijohen janë HttpConnection, UDPDatagramConnection, SipConnection.
Protocol:Protokolli që do të përdoret për lidhjen. Protokolli përdoret nga GCF për të gjetur klasën e saktë që do të përdoret.
Address:Adresa në rrjet e pikës fundore të lidhjes. Klasat Connection që suportojnë funksionalitete server të lejojnë të specifikosh vetëm portën e lidhjes, p.sh socket://:80 krijon një lidhje socket në server në portën 80 të localhost.
Parameters:Në lidhje mund të përcaktohen në mënyrë opsionale disa parametra ekstra. P.sh lidhja SipConnection të lejon të shtosh parametra transporti. Parametrat gjithmonë specifikohen si listë me çifte name = value të cilët ndahen nga njëri-tjetri me pikëpresje. P.sh:
SipConnection sc = ( SipConnection )Connector.open (“sip:+475551234567; postd = [email protected]; user=phone“);
Teknologjia e standardizimit në Java E gjithë teknologjia Java kalon përmes procesit JCP (Java
Community Process.Procesi mbikëqyret nga EC(Executive Committee). Ekzistojnë dy komitete ekzekutive: një për J2SE dhe J2EE, dhe një për J2ME. Është detyrë e EC që të mbledhë, zhvillojë dhe të aprovojë JSR(Java Specification Request). Rezultati i këtij procesi përbëhet nga tre artefakte:
Specifikimi: Është API përfundimtare, përmban klasat dhe manualin që i shpjegon përdoruesit se si ta përdorë këtë teknologji.
TCK(Test Compatibility Kit): Përfshin testet që duhet të kalojë një specifikimin.
RI(Reference Implementation): Është implementim i specifikimit i cili i lejon përdoruesit që të fillojnë të punojnë me të.
Mobile Service Architecture
MSA u finalizua në Dhjetor 2006 si zhvillim i JTWI. Në këtë specifikim janë shtuar shumë më tepër paketa opsionale, siç tregohet në Figurën 6. Përveç MSA dhe MSA Subset ekziston gjithashtu MSA Advanced Specifikation. Si konfigurim për MSA mund të përdoret edhe CDC. Pajisjet mobile mund të suportojnë të gjithë MSA ose vetëm një pjesë të teknologjive të përfshira në të.
Mjedisi zhvillues
Për të programuar në NetBeans me J2ME është e nevojshme që paraprakisht në kompjuter të jenë të instaluar:
Java SE Development Kit (JDK) 5.0.6 e tutje. NetBeans IDE NetBeans Mobility Pack për CLDC dhe/ose CDC. Paketat duhet të instalohen sipas radhës së mësipërme. Gjithashtu
ekziston një opsion për shkarkimin e NetBeans IDE së bashku me JDK-në.
Shtimi i një librarie të re në Netbeans
Lecture 1 IntroductionProgramming Handheld
and Mobile devices20
Mobile information devices most people probably think of portable devices as intelligent phones
or personal digital assistants (PDAs), the distinction is arbitrary. For the purposes of this course we will use the term MID to include
any handheld device which has some form of micro-processor in it and which can have new applications loaded onto it.
Shembull: Krijimi i një aplikacioni MIDlet
Dy hapat e tjerë kanë të bëjnë me konffigurimin e pajisjes emulator për sa i përket tipit dhe pam jes së saj. Më pas paketën <default package> të projektit mund të shtohen MIDlet-e. Më poshtë tregohet kodi burim i një MIDlet-i të thjeshtë dhe pamja se si duket në emulator.
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class HelloWorld extends MIDlet { Display display ;
Form form ;
public void startApp() {
display = Display.getDisplay(this); form = new Form("Helloworld example"); form.append("Hello World!"); display.setCurrent(form);
}
public void pauseApp() {}
public void destroyApp(boolean unconditional) { notifyDestroyed( );
}}
Hedhja e MIDlet-it në telefon
Pasi projekti kompilohet, NetBeans krijon Suitën MIDlet për projektin e cila gjendet në folderin HelloWorld/dist. Në polder gjenden dy skedarë HelloWorld.jad dhe Helloworld.jar. Skedari i dytë është arkivi që ka të gjithë skedarët që i duhen aplikacionit që të punojë. Rrjedhimisht për të instaluar MIDlet-in në telefon ky arkiv duhet të transferohet fillimisht në telefon. Në disa raste të veçantë duhet të transferohet edhe skedari .jad. Pasi dërgohet skedari në telefon, fillohet instalimi duke hapur këtë skedar.
25
Mobile information devices
The emergence of genuinely portable devices which contain sufficient computing power to support a range of applications, many of which were originally developed for conventional personal computers, is one of the major changes in the world of technology in recent years.
It has accompanied the emergence of very widespread adoption of mobile phones and these technologies are now merging, creating mobile information devices (MIDs) with the ability to connect with each other and with
conventional computer networks
26
Operating environments
Palm OS J2ME Other Java environments .Net Compact Symbian Linux
Lecture 1 IntroductionProgramming Handheld
and Mobile devices27
Languages
C/C++ Palm OS Symbian .NET Linux
Java J2ME Other Java environments
C# .NET
Visual Basic .NET
Python scripting Some mobile phones
Mobile scripting languages Many mobile phones
Lecture 1 IntroductionProgramming Handheld
and Mobile devices28
Issues to bear in mind
Screen SizeMost Palm Powered handheld screens are only 160x160
pixels, so the amount of information you can display at one time is limited.
Quick Turnaround ExpectedOn a PC, users don’t mind waiting a few seconds while an
application loads because they plan to use the application for an extended amount of time. By contrast, the average handheld user uses a handheld application 15 to 20 times per day for much briefer periods of time, usually just a few seconds.
Lecture 1 IntroductionProgramming Handheld
and Mobile devices29
More issues to bear in mind
PC Connectivity PC connectivity is an integral component of the Palm Powered
handheld. The handheld comes with a cradle that connects to a desktop PC and with software for the PC that provides “one button” backup and synchronization of all data on the handheld with the user’s PC.
Input Methods Most users of Palm Powered handhelds don’t have a keyboard
or mouse. Users enter data into the handheld using a pen. They can either write characters in the input area or use the keyboard dialog provided on the handheld.
Lecture 1 IntroductionProgramming Handheld
and Mobile devices30
More issues to bear in mind
Power Handhelds run on batteries and thus do not have the same processing
power as a desktop PC. The handheld is intended as a satellite viewer for corresponding desktop applications. If your application needs to perform a computationally intensive task, you should implement that task in the desktop application instead of the handheld application.
Memory Palm Powered handhelds have limited heap space and storage space.
Different versions of the handheld have between 512K and 8MB total of dynamic memory and storage available. The handheld does not have a disk drive or PCMCIA support.
Lecture 1 IntroductionProgramming Handheld
and Mobile devices31
More issues to bear in mind
File SystemBecause of the limited storage space, and to make
synchronization with the desktop computer more efficient, Palm OS does not use a traditional file system. You store data in memory chunks called records, which are grouped into databases.
Backward CompatibilityDifferent versions of Palm Powered handhelds are
available, and each runs a different version of Palm OS. Users are not expected to upgrade their versions of Palm OS as rapidly as they would an operating system on a desktop computer.
Binary executable files on the device. Can access all API’s made available by OS vendor. SDK’s are platform-specific. Each mobile OS comes with its own unique tools and
GUI toolkit.Different tools, languages and distribution channels associated with leading mobile operating systems
* IBM, Native, web or hybrid mobile app development, 2012. IBM Software Thought Leadership White Paper
PROS
Easy low-level hardware access services.
Easy access to high level services important to personal mobile experience.
Full use of all functionalities that modern mobile devices have to offer.
High usability.
CONS
Code Reusability : Low
Development & maintenance: Time-consuming & expensive.
Designers are required to be familiar with different UI components of each OS.
Upgrade flexibility: Low.
Separates build environment from target environment. Platform-independent API using a mainstream programming language like
JavaScript, Ruby or Java. The cross-compiler then transforms the code into platform-specific native apps. The software artifact generated can be deployed and executed natively on the
device.
ADVANTAGES: Improved performance and User Experience. Full access to functionalities of underlying mobile OS and device specific
capabilities.
DISADVANTAGES: Highly complex as cross-compilers are difficult to program. Need to be kept consistent with fragmented mobile platforms and operating
systems available.
A virtual machine is used to abstract the target platform details from the application’s running code.
The framework provides both the API and runtime environment. The runtime executes on the mobile device and enables interoperability
between the device’s OS and the mobile application.
ADVANTAGES: Improved performance and User Experience. Full access to functionalities of underlying mobile OS and device specific
capabilities. Portability: VM’s are easier to maintain & more flexible to extend.
DISADVANTAGES: Slower due to runtime interpretation latency.
Use standard web technologies such as HTML 5, CSS 3 & JavaScript. Features of HTML 5 - Advanced UI components, access to rich media types,
geolocation services & offline availability. Increasing popularity of HTML 5 in rendering engines such as WebKit. Runs on a standalone mobile web browser. Installed shortcut, launched like a native app. UI logic resides locally; makes the app responsive and accessible offline.
ADVANTAGES: Multiplatform support. Low development cost. Leverage existing knowledge.
DISADVANTAGES: Limited access to OS API’s.
Combines native development with web technology. The web app runs inside a thin wrapper native app. The wrapper native app uses the OS API’s to create an embedded HTML
rendering engine which provides a bridge between the browser and device API’s.
The communication between web app and native app normally happens over JavaScript via custom built API’s.
ADVANTAGES: Flexibility of web apps combined with feature richness of native apps. Simplified deployment and immediate availability. Leverage existing knowledge.
DISADVANTAGES: Poorer user experience as compared to native apps. Access to advanced device capabilities normally restricted.
PROS
Code Reusability
Plugins
Easy for web developers
Reduced development costs
Support for enterprise & cloud services
Easy Deployment
CONS
Might not support every feature of OS
Cannot use own tools/IDE
Slower.
High end graphics & 3D support limited
Vendor lock-in
http://setandbma.files.wordpress.com/2011/12/wora-platforms.png
TECHNICAL ARCHITECTURE: Cross compilation using Virtual Machine.Single source codebase written in Ruby and UI constructed using HTML 5, CSS 3, JavaScript running on Ruby interpreter on the device.Support for SQLite enables the local storage of relational data, enabling offline capabilities for both hybrid and native HTML 5 applications.
DESIGN PATTERNS:Model-View-Controller pattern for maintainability and best practices.Object Relational Mapper design for easy data manipulation.
SUPPORTED PLATFORMS:WM /WEHH , WinCE5.0+, Android 2.1+, iOS 3.0+, BB 4.6+, WP7
*http://leckylao.files.wordpress.com/2010/06/screen-shot-2010-06-12-at-3-28-30-pm.png
HTML 5 FEATURES:App Caching, WebSockets, WebWorkers, Local & Session Storage, SQLite, Semantic Elements, Form Attributes
IDE USED:RhoStudio – An Eclipse based IDE
STRENGTHS:Design patterns used.Applications look and behave identically on all devices.
WEAKNESSES:Updating HTML/JavaScript code needs a complete rebuild.Need to know Ruby well, which is not as popular as other programming languages.Doesn’t generate source code, only native package which can restrict any further tweaking of the app.
http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/
TECHNICAL ARCHITECTURE: Web approach using hybrid model.Single source codebase written HTML 5, CSS 3, JavaScript running on a mobile browser embedded in a native app wrapper.Device capabilities accessed through device-independent JavaScript API.
SUPPORTED PLATFORMS:iOS, Android, Blackberry, WP7, Symbian, Palm, Samsung Bada
IDE USED:MAC OS X & XCODE for iPhone & iPad.Google Android SDK, Eclipse ADT Plugin, Ant as well as Eclipse IDE for Android.
ARCHITECTURE:
* http://arnab.ch/images/phonegap-architecture.jpg
STRENGTHS:Native wrapper source code is provided so it can be customized further.Simple ‘drop-in libraries’ concept makes it easier to develop.Lowers barriers of adoption for web developers.
WEAKNESSES:Lack of support for native UI components, design patterns & development tools.The capabilities offered by the framework is limited to what a “WebView” can do.Different projects for different platformsDifferent JavaScript files on each platform for PhoneGap itself and pluginsNo native UI supportJava, Objective-C or C# requirement to create new pluginsNo built-in support for push notifications
* http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/
TECHNICAL ARCHITECTURE: Cross compilation technique – Pre-compilation, front-end compilation, platform & package compilation.Single source codebase written in JavaScript, compiled into native code and packaged for different target platforms.Does not use browser engine to render user interface on mobile devices. Instead the UI elements are converted to true native UI elements when deployed to the phone.
SUPPORTED PLATFORMS:iOS, Android, Windows & Blackberry
IDE USED:Studio, an Eclipse-based IDE
* http://www.linux-mag.com/s/i/articles/7719/architecture1.png
STRENGTHS: Native code output very quick and fluid on the phone.Easy setup and startup for developers.Excellent documentation & examples.Strong community forum to find out answers.Intuitive app management environment.Support for desktop and tablet development
WEAKNESSES:Potentially restrictive API’sTries to solve too many problems in one shot supporting phones, tablets & desktops.
* http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/
TECHNICAL ARCHITECTURE: Cross compilation using Virtual Machine.Single source codebase written in C/C++ or HTML/JavaScript or a combination of both.C++ source code platform-independent intermediate code application package
SUPPORTED PLATFORMS:iOS, Android, Windows Mobile, Moblin/MeeGo, Symbian & Blackberry
IDE USED:MoSync IDE based on Eclipse.
http://www.straightforward.se/storyserver/sites/straightforward.se.storyserver/files/images/MoSyncAppArchitecture.preview.png
STRENGTHS: Only one project structure for all the platforms.The same JavaScript file.Extend JavaScript functionality using C++ or Java and Objective-CNative UI supportBuilt-in support for push notificationsTarget group: Both web developers looking to enter the mobile space, as well as the ordinary PC/Mac desktop developer with knowledge of C/C++.
WEAKNESSES:No support for accelerometer or camera in most phones.Contains XML parsing libraries but lacking support for JSON or other data formats.Doesn’t provide support for MVC; requires little extra effort to create views for data.
* http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/
* http://floatlearning.com/2011/07/which-cross-platform-framework-is-right-for-me/
Tools
Phone Eclipse ( http://www.eclipse.org/downloads/ )
Android Plugin (ADT) Android SDK ( http://developer.android.com/sdk/index.html )
Install everything except Additional SDK Platforms, unless you want to
Windows Users: may need to install Motorola Driver directly ( http://www.motorola.com/Support/US-EN/Support-Homepage/Software_and_Drivers/USB-and-PC-Charging-Drivers
)
Android SDK
Once installed open the SDK Manager Install the desired packages Create an Android Virtual Device (AVD)
SDK Manager
AVD
ADT Plugin (1)
In Eclipse, go to Help -> Install New Software Click ‘Add’ in top right Enter:
Name: ADT Plugin Location: https://dl-ssl.google.com/android/eclipse/
Click OK, then select ‘Developer Tools’, click Next Click Next and then Finish Afterwards, restart Eclipse Specify SDK location (next 3 slides)
Must do this every time start a new project in a new location (at least in Windows)
ADT Plugin (2)
ADT Plugin (3)
ADT Plugin (4)
Creating a Project (1)
Creating a Project (2)Need
the
items
circled
Then
click
Finish
Project Components src – your source code gen – auto-generated code (usually just R.java) Included libraries Resources
Drawables (like .png images)LayoutsValues (like strings)
Manifest file
XML
Used to define some of the resourcesLayouts (UI)Strings
Manifest file Shouldn’t usually have to edit it directly, Eclipse can
do that for you Preferred way of creating UIs
Separates the description of the layout from any actual code that controls it
Can easily take a UI from one platform to another
R Class
Auto-generated: you shouldn’t edit it Contains IDs of the project resources Enforces good software engineering Use findViewById and Resources object to
get access to the resourcesEx. Button b = (Button)findViewById(R.id.button1)Ex. getResources().getString(R.string.hello));
Layouts (1)
Eclipse has a great UI creatorGenerates the XML for you
Composed of View objects Can be specified for portrait and landscape
modeUse same file name, so can make completely
different UIs for the orientations without modifying any code
Layouts (2)
Layouts (3) Click ‘Create’ to make layout modifications When in portrait mode can select ‘Portrait’ to make a
res sub folder for portrait layouts Likewise for Landscape layouts while in landscape mode Will create folders titled ‘layout-port’ and ‘layout-land’
Note: these ‘port’ and ‘land’ folders are examples of ‘alternate layouts’, see here for more info http://developer.android.com/guide/topics/resources/providing-resources.html
Avoid errors by making sure components have the same id in both orientations, and that you’ve tested each orientation thoroughly
Layouts (4)
Strings
In res/valuesstrings.xml
Application wide available strings Promotes good software engineering UI components made in the UI editor should have
text defined in strings.xml
Strings are just one kind of ‘Value’ there are many others
Manifest File (1)
Contains characteristics about your application When have more than one Activity in app, NEED to
specify it in manifest file Go to graphical view of the manifest file Add an Activity in the bottom right Browse for the name of the activity
Need to specify Services and other components too Also important to define permissions and external
libraries, like Google Maps API
Manifest File (2) – Adding an Activity
Android Programming Components Activity
http://developer.android.com/guide/topics/fundamentals/activities.html
Service http://developer.android.com/guide/topics/fundamentals/services.html
Content Providers Broadcast Receivers
Android in a nutshell: http://developer.android.com/guide/topics/fundamentals.html
Activities (1)
The basis of android applications A single Activity defines a single viewable
screen the actions, not the layout
Can have multiple per application Each is a separate entity They have a structured life cycle
Different events in their life happen either via the user touching buttons or programmatically
Activities (2)
Services (1) Run in the background
Can continue even if Activity that started it dies Should be used if something needs to be done while the user is not
interacting with application Otherwise, a thread is probably more applicable
Should create a new thread in the service to do work in, since the service runs in the main thread
Can be bound to an application In which case will terminate when all applications bound to it unbind Allows multiple applications to communicate with it via a common
interface Needs to be declared in manifest file Like Activities, has a structured life cycle
Services (2)
Running in Eclipse (1)
Similar to launching a regular Java app, use the launch configurations
Specify an Android Application and create a new one
Specify activity to be run Can select a manual option, so each time program
is run, you are asked whether you want to use the actual phone or the emulatorOtherwise, it should be smart and use whichever one is
available
Running in Eclipse (2)
Running in Eclipse (3)
Running in Eclipse (4)
USB Debugging
Should be enabled on phone to use developer features
In the main apps screen select Settings -> Applications -> Development -> USB debugging (it needs to be checked)
Android Debug Bridge
Used for a wide variety of developer tasksRead from the log fileShow what android devices are available Install android applications (.apk files)
In the ‘platform-tools’ directory of the main android sdk directoryRecommend putting this directory and the ‘tools’
directory on the system path adb.exe
Debugging Instead of using traditional System.out.println, use the Log class
Imported with android.util.Log Multiple types of output (debug, warning, error, …) Log.d(<tag>,<string>)
Can be read using logcat. Print out the whole log, which auto-updates
adb logcat Erase log
adb logcat –c Filter output via tags
adb logcat <tag>:<msg type> *:S can have multiple <tag>:<msg type> filters <msg type> corresponds to debug, warning, error, etc. If use Log.d(), then <msg type> = D
Reference http://developer.android.com/guide/developing/debugging/debugging-log.html
Screen Shots
Some say you need to root the phone – that is not true
One option: Android Screen Capturehttp://www.mightypocket.com/2010/08/android-
screenshots-screen-capture-screen-cast/ It’s slow, but fine for screenshots of applications
whose screens aren’t changing fastRead their installation help, following the extra steps if
need be (I had to copy adb.exe and some dll files, as they explain)
Maps Example (1)
Using Google Maps in your app Setup project to use ‘Google API’ version Edit Manifest file
To indicate the app will use maps and the internet Get a maps API key Note: Google Maps API can display a map and draw overlays, but
is not the full Google Maps experience you enjoy on the web For example, there does not seem to be inherent support for
drawing routes between points (if you find it let me know)…however, you can draw lines between points and almost any type of overlay, but that’s different than street routes
The directions API is a web service, which is different, among several other Google web services
Read the Google API terms of use
Maps Example (2)
Maps Example (3) – Manifest (1) Open Manifest file Add map library tag
Add the ‘Uses Library’ com.google.android.maps Indicate the app will access the internet
Add the ‘Permission’ android.permission.lNTERNET End goal is to add the following two lines to XML file,
under the <manifest> and <application tags>, respectively Under the <manifest> tag
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
Under the <application> tag <uses-library android:name="com.google.android.maps"></uses-library>
Following is GUI way to add them
Maps Example (4) – Manifest (2)
1
2
Maps Example (5) – Manifest (3) Select ‘Add’ under ‘Uses Library’ (last
slide) Then select ‘Uses Library at this prompt Set name as: com.google.android.maps
(next slide) and save
Maps Example (6) – Manifest (4)
Maps Example (7) – Manifest (5)
2
1
Maps Example (8) – Manifest (6) Select ‘Permissions’ and then ‘Add’ (last
slide) Select ‘Uses Permissions’ at this prompt Set name to:
android.permission.INTERNET and save (next slide)
Maps Example (9) – Manifest (7)
Maps Example (10) – Maps API Key (1)
All Android applications need to be signedThe debug mode signs for you with special debug
certificate All MapView elements in map applications
need to have an API key associated with themThat key must be registered with the certificate
used to sign the app When releasing app, need to sign with a
release certificate and get a new API Key
Maps Example (11) – Maps API Key (2) For debug mode, get the MD5 fingerprint of the debug certificate
Locate the ‘keystore’ Windows Vista: C:\Users\<user>\.android\debug.keystore Windows XP: C:\Documents and Settings\<user>\.android\debug.keystore OS X and Linux: ~/.android/debug.keystore
Use Keytool (comes with Java, in the bin directory with the other Java tools, should put that dir on system PATH) to get fingerprint
keytool -list –v -alias androiddebugkey -keystore “<path_to_debug_keystore>” -storepass android -keypass android
If don’t include –v option, then will probably get only 1 fingerprint, and if it’s not MD5, then need –v (Java 7 needs –v)
Extract the MD5 fingerprint, SHA will not work unfortunately Go to https://code.google. com/android/maps-api-signup.html ,
agree to terms and paste MD5 fingerprint, you will then be given an API Key
Maps Example (12)
Need to put MapView tag in XML com.google.android.maps.MapView MapView is the basic view that represents a Google Map
display Must include API Key in XML, inside a layout
<com.google.android.maps.MapViewandroid:id="@+id/mapview"android:layout_width="fill_parent"android:layout_height="fill_parent"android:clickable="true"android:apiKey=“<api key>”/>
Maps API Reference http://code.google.com/android/add-ons/google-apis/reference/index.html
Acknowledgements
Android Developer’s Website Activity and Service life-cycle flow charts Tons of other Android info
Google Maps API external library http://code.google.com/android/add-ons/google-apis/maps-overview.html
MightyPocket http://www.mightypocket.com/2010/08/android-screenshots-screen-capture-screen-cast/
Numerous Forums & other developer sites, including: http://www.javacodegeeks.com/2011/02/android-google-maps-tutorial.html http://efreedom.com/Question/1-6070968/Google-Maps-Api-Directions http://www.mail-archive.com/[email protected]/msg28487.html http://android.bigresource.com/ threads http://groups.google.com/group/android-developers threads Many http://stackoverflow.com threads http://www.anddev.org/google_driving_directions_-_mapview_overlayed-t826.html
Zainan Victor Zhou – for advice and his own tutorial
Advanced Android Topics The first mile on Android: relatively straight forward
Should already know Java GUI is roughly drag and drop Lots of documentation and examples online…
Let’s get a little more advanced… Debugging on an Android device Persistent application storage (Preferences, Database) Writing and linking non-Java code (e.g., C and C++) Cross-compiling useful libraries to Android Modifying the kernel (e.g., to add support, remove
permissions) NFC support
Some More Advanced Layouts As mentioned, we have a research project on
Android which uses a lot of advanced features and different layouts Good examples of how to embed layouts within
each other…
These layouts are available in our project:https://github.com/gnychis/android-wmon/tree/master/application/res/layout
Root: What do you need it for? Like “jailbreaking” -- a term most are familiar with
Think of it as: it literally just gives you Linux root access
What don’t you need it for? Writing a standard application that uses standard APIs and HW Writing native code that does not touch some aspects of F.S.
What do you need it for? Modifying and replacing the kernel
E.g., to remove permission checks, modify TCP, modify WiFi stack… Loading and/or removing new kernel modules Modifying anything in /system or snooping around /data Modifying the Android OS or APIs Changing the ROM on the device (new OS + kernel)
Debugging
As usual, two ways to have debug information:1. Android has a logging utility to print information to
2. Full debugger through ADB and Eclipse
Logging utility: good for printing periodic status of application and/or certain variables
Debugger: great for stepping through code, able to: Set breakpoints and conditions Check the values of any variable
Tag Message
Persistent Storage
You are likely going to want to persistently store data
In Android, there are 5 main ways to store data:1. Shared Preferences – private key-value pair storage
2. Internal Storage – private storage per-application
3. External Storage – local shared storage (e.g., on SD card)
4. SQLite Database – private structured data
5. Network Storage – store data on your own server
You should be able to make a decision on which solution is best for various data in your application Use multiple storage options!
Shared Preferences Overview
Good for basic data storage, simple examples:Has the user completed the application settings? (boolean)What is the user’s username? (string)
Shared Preferences accessed by string key, value can be:boolean, float, int, long, string
Arbitrary objects cannot be stored in Shared Preferences, best two options for arbitrary objects:Marshal to/from a private database (best)Marshal to/from binary files in private storage
Shared Preferences Example
Name preference file (does not need to be globally unique)
Get a handle to your preferences:
Can read in values by key, specify value if does not exist
Writing needs specific handle, and need to commit all changes
Do not forget
SQLite Database
Should hopefully know the basics of databases
Best to store your main data/objectsMarshal your classes to and from a row in a database
Android provides some useful helper classesSQLiteDatabase, Cursor, ContentValues….
Ultimately, I want to push you in the right direction, but you should be able to find the details…Good example: http://www.androidhive.info/2011/11/android-sqlite-
database-tutorial/
Writing Native Code (JNI) JNI: framework that allows Java code to call, or be called by,
native applications/libraries in other languages E.g., Java code can call a function written in C++, and visa-versa
Easiest way to integrate pre-existing code and libraries in other languages (e.g., a pre-existing C encryption library)
Good to implement certain functionality which can be written more optimally in C, for example
Native code still runs within the application’s VM Follows AndroidManifest (e.g., need “INTERNET” for sockets)
Android NDK: Toolset integrate/compile JNI in to Android app
The Structure of Native Code Directory structure: native code fits in “jni”
directory
ndk-build uses Android.mk in each native directory
Top-Level Android.mk
Best way to make top-level Android.mk:
You can cross-reference in-between libraries E.g., stringlib can use a function found in mathlib, the stringlib
Android.mk file just needs to specify it links mathlib
List each subdirectory for ndk-buildto enter and build individually.
Individual Library Android.mk
Each library needs its own Android.mk, with:Local source files, linker/compiler flags, output
(e.g., shared lib) Something a little more advanced, for example:
Creates lib_____.so (i.e., libawmon.so)
Simple Native C Code Example
Need to include JNI environment header, logging also useful
Native function is passed …Java environment: often used to allocate new
Java objectsJava class object: Your Parameters: any C/C++ primitives
__android_log_print(ANDROID_LOG_INFO, “NativeMath”, ”Error: %d”, eval);
Must match your package name(case sensitive)
Must match the class accessing and calling the native code(case sensitive)
Building NDK Code Make sure ndk-build is in your PATH env. Variable
Standard Android documentation should get you this far…
From the base of your application directory (outside jni dir):
All of your built libraries are copied to libs/armeabi/
The Eclipse Gotcha YOU MUST REFRESH YOUR DIRECTORY
IN ECLIPSE!! Eclipse does not look
for changes, even if you were to rebuild app
You must refresh everytime you run ndk-buildotherwise your changeswill not be included
Maybe something built into Eclipse now?
Accessing Native Code in Java
Must load each native library: e.g., Can be done in any class or thread It is a blocking call, to keep in mind if loading large
libraries…
Must create native function prototypes in respective classes:
Once done, you can access these functions directly:
Using External Libraries
“I need a library to help me with _____, but it is a standard C or Linux implementation” (e.g., crypto library)
Proceed in this order:
1. Google “____ Android” – many libraries already cross-compiled
2. Write custom Android.mk to cross-compile it You will be surprised how many libraries you find cross-compiled,
and even if an older version: use their Android.mk
Cross-Compiling Libraries For many libraries, look at the Makefile and see which source files it
uses to build the library Add these sources to Android.mk “LOCAL_SRC_FILES” Use similar CFLAGS, LDFLAGS
Common for libraries to link to pthread, remove –lpthread but keep most pthread code. Custom pthread force linked
Look at the many examples online, including our own: libpcap, libnl, libgcrpyt, libglib, libgpg, libusb ….
https://github.com/gnychis/android-wmon/tree/master/application/jni
Modifying the Kernel Several key steps to modifying the kernel…
1. Obtaining the proper source code for HW + OS version If you get the wrong kernel: phone will not boot (I’ll help
you…)
2. Modifying the kernel (we’ll give you some pointers…)
3. Cross-compiling the kernel using the NDK
4. Installing the kernel (BE CAREFUL: CAN BRICK PHONE) Best to use something called “AnyKernel” package
This needs to be done in Linux (e.g., in a Virtual Machine)
Obtaining Kernel Source Code The two possible phones you are using for this class:
Galaxy Nexus: code name “maguro” (“tuna” for kernel)
Galaxy S: code name “crespo” Best to start at this link: https://android.googlesource.com/ Kernel source code depends on the HW, for you:
Galaxy Nexus: https://android.googlesource.com/kernel/omap.git
Nexus S: https://android.googlesource.com/kernel/samsung.git
In “About Phone” you can find your git kernel commit:3.0.31-g<hash> (i.e., d5a18e0)… make sure to drop the g that is prepended to the hash
Building the Kernel
Build using cross-compiler provided by Google:
Setup your environment:
Checkout your kernel version: git checkout <hash> Setup with the proper configuration
Galaxy Nexus: make tuna_defconfigNexus S: make crespo_defconfig
Finally, you can build with: make
Packaging the Kernel – Pt1
Need to create a ramdisk with the the proper init scripts Can be extracted from the device, but we will provide
you with it See example…
Modifications to ramdisk are needed if you want to: Load kernel modules on boot Set permissions to certain devices/files on boot Change the order services are initialized
Packaging the Kernel – Pt2 This is very tricky, and must be done properly or you will
“brick” the phone, i.e., it will not boot and must be repaired
Install without building the entire OS by creating “update” ZIP Runs a script to mount FS and extract kernel &
modules Usually includes system directory which is extracted
What the updater script looks like for Galaxy Nexus:
Packaging the Kernel – Pt3
Example hierarchy of the update ZIPBoot image with kernel at root
These are standard
Specific to device,updater script
MUST put allkernel modulesin here that wererebuilt with kernel
Installing the Kernel Need to use “recovery” mode on the phone to install
Dedicated, bootable partition with recovery console
Put your updater zip on your SD card, then:
Use recovery toinstall the ZIP
Kernel Pointers
Based on the project page, some kernel locations you might be interested in….
WiFi Driver: drivers/net/wireless/bcmdhd
TCP Protocol / Sockets: net/ipv4 include/net
Permissions (e.g., sockets): kernel/capability.c
Near Field Communication
Low rate short distance wireless communication Approx. 10 centimeters supported 424 kbit/s across 13.56MHz
Current applications: payments, smart posters, check-ins…
Two major NFC modes: Reader / Writer mode Peer-to-Peer mode (emulate tags on Android)
Nexus S was first phone to really “mainstream” NFC
NDEF (NFC Data Exchange Format) Standard data format created by NFC Forum
NDEF Messages: basic transportation mechanism Can contain one or more NDEF Records
NDEF Record: contain specific structure with payload TNF contains the
record type(e.g., URI)
Tag Read / Write Example Start with basic tag read and write example
Includes P2P mode ability
This was an example posted by Google that we modified to make a little more intuitive
Sample code was posted for you:
https://github.com/gnychis/stickynotes
The Basic NFC Permissions
As usual, you need to have Android permissions Important to specify minimum SDK Ensure that the phone has NFC support
Receiving NFC Tag Information
Remember, all information in Android is broadcast For NFC, you register to receive TAG read broadcasts:
Registering for NFC Data
Specify that the Activity should receive NFC Intents:
Can specify which data types the application should receive:
Need a handle to the “NFC Adapter” (i.e., hardware)
Apply and enable the filter in onResume()
Receiving the NFC Data – Pt1
Receive callbacks in “onNewIntent()” you override:
Receiving the NFC Data – Pt2
NDEF Messages come in as an array Then, you can go through the msgs array and get the payload:
Detecting Nearby Tag to Write
Just like you registered to receive NFC tag data, you register to know when a tag is simply detected and then use it to trigger a write to it:
When the user specifies to write, you enable this filter and use a software flag to know that you should write when the tag is detected nearby: