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



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



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.



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.




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.




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.

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.

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

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

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


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 (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:

Programim Mobile Leksion Tema: Programimi Mobile në Java.

Documents

Transcript of Programim Mobile Leksion Tema: Programimi Mobile në Java.