The AndroidManifest.xml File - ìëë¡ì´ë ê¸°ì ì»¤ë®¤ëí° : Korea ...

안드로이드 애플리케이션 교육 자료 – 7 

AIDL and Services 

www.kandroid.org 운영자 : 양정수 (yangjeongsoo@gmail.com), 닉네임:들풀

9. 퍼미션(Permission)의 protectionLevel이 의미하는 바 

안드로이드 보안 모델에 대한 이해는 기본적으로 리눅스 기반의 프로세스들 간의 격리, 애플리케 

이션을 위한 고유한 사용자 ID의 부여, 애플리케이션 고유의 파일시스템, 애플리케이션에 대한 사 

인 구조에 기반한다. 이러한 보안 구조는 기본적인 리눅스 보안 모델과 Java의 애플리케이션 사인 

모델에 기초한다. 이러한 전통적 보안 모델에 추가된 안드로이드 고유의 보안 모델이 퍼미션 

(Permission)이다. 안드로이드는 컴포넌트들 간의 바인딩(또는 호출) 및 API 사용시 퍼미션을 적용 

하는 구조를 제공한다. 퍼미션은 이미 정의된 것들도 있지만, 누구나 정의하고 강제할 수 있다. 퍼 

미션은 안드로이드 매니페스트 파일의 permission 엘리먼트를 사용해서 정의되며, 해당 엘리먼트 

는 protectionLevel이라는 애트리뷰트를 가진다. protectionLevel은 normal, dangerous, signature, 

signatureOrSystem 중 하나의 값을 가진다. 여기에서 주목할 만한 것은 dangerous와 signature이 

다. 만약 컴포넌트에 강제된 permission에 대한 protectionLevel이 normal이라면 사용자의 승인을 

요구한다는 것이며, signature 또는 signatureOrSystem이라면 동일한 인증서로 사인된 컴포넌트 

들간에만 바인딩(또는 호출) 및 API 사용이 가능하다는 것이다. 더불어 안드로이드 플랫폼내에는 

이미 다양한 애플리케이션들과 API가 존재하며, 이와 관련되어 4개의 인증서가 디폴트로 사용되 

고 있다. 이것이 의미하는 바 역시 좀 더 깊숙이 고찰하는 것도 필요하다. 

Korea Android Community- www.kandroid.org 

2

1. AIDL and Services

애플리케이션 개요 : 컴포넌트 생명주기 

Service 생명주기 

A service can be used in 

two ways: 

Service is 

started by 

startsService() 

Service is 

started by 

bindService() 

Context.startService() 

It can be started and 

allowed to run until 

someone stops it or it 

stops itself. 

onCreate() 

onStart() 

onCreate() 

onBind() 

Context.bindService() 

Service is 

running 

Client interacts with the service 

onRebind() 

It can be operated 

programmatically using 

an interface that it 

defines and exports. 

The service 

is stopped 

(no callback) 

onDestory() 

onUnbind() 

onDestory() 

Service is 

Shut down 

Service is 

Shut down 


4

애플리케이션 개요 : Processes & Threads 

Remote procedure calls 

Android has a lightweight 

mechanism for remote procedure 

calls (RPCs) - where a method is 

called locally, but executed 

remotely (in another process), with 

any result returned back to the 

caller. 

defined 

by 

Android 

Binder 

class 

IBinder 

interface 

This entails decomposing the 

method call and all its attendant 

data to a level the operating 

system can understand, 

transmitting it from the local 

process and address space to the 

remote process and address 

space, and reassembling and 

reenacting the call there. 

Interface generated 

by the aidl tool 

defined 

by 

application 

Stub 

inner class 

class that implements 

the interface 

inner class 

Used by Android 

… 

used remotely 

(by the service) 

used locally 

(by clients of the service) 


5

AIDL (Android Interface Definition Language) 

IDL File 

idl tool 

Code 

- C 

- C++ 

- Java 

- Perl … 

AIDL File 

aidl tool 

Java 

Code 

aidl 


6


Designing a Remote Interface Using AIDL 

Since each application runs in its own process, and you can write a service that runs in a 

different process from your Application's UI, sometimes you need to pass objects between 

processes. On the Android platform, one process can not normally access the memory of 

another process. So to talk, they need to decompose their objects into primitives that the 

operating system can understand, and "marshall" the object across that boundary for you. 

The code to do that marshalling is tedious to write, so we provide the AIDL tool to do it for 

you. 

AIDL (Android Interface Definition Language) is an IDL language used to generate code that 

enables two processes on an Android-powered device to talk using interprocess 

communication (IPC). If you have code in one process (for example, in an Activity) that 

needs to call methods on an object in another process (for example, a Service), you would 

use AIDL to generate code to marshall the parameters. 

The AIDL IPC mechanism is interface-based, similar to COM or Corba, but lighter weight. It 

uses a proxy class to pass values between the client and the implementation. 

• Implementing IPC Using AIDL 

• Calling an .aidl (IPC) Class 


7


Implementing IPC Using AIDL 

Follow these steps to implement an IPC service using AIDL. 

1. Create your .aidl file - This file defines an interface (YourInterface.aidl) that defines the 

methods and fields available to a client. 

2. Add the .aidl file to your makefile - (the ADT Plugin for Eclipse manages this for you). 

Android includes the compiler, called AIDL, in the tools/ directory. 

3. Implement your interface methods - The AIDL compiler creates an interface in the Java 

programming language from your AIDL interface. This interface has an inner abstract 

class named Stub that inherits the interface (and implements a few additional methods 

necessary for the IPC call). You must create a class that extends YourInterface.Stub and 

implements the methods you declared in your .aidl file. 

4. Expose your interface to clients - If you're writing a service, you should extend Service 

and override Service.onBind(Intent) to return an instance of your class that implements 

your interface. 


8


Implementing IPC Using AIDL : Creating an .aidl File 

AIDL is a simple syntax that lets you declare an interface with one or more methods, that can 

take parameters and return values. These parameters and return values can be of any type, 

even other AIDL-generated interfaces. However, it is important to note that you must import all 

non-built-in in types, even if they are defined in the same package as your interface. Here are the 

data types that AIDL can support: 

• Primitive Java programming language types (int, boolean, etc) - No import statement is needed. 

• One of the following classes (no import statements needed): 

• String 

• List - All elements in the List must be one of the types in this list, including other AIDL-generated 

interfaces and parcelables. List may optionally be used as a "generic" class (e.g. List). The 

actual concrete class that the other side will receive will always be an ArrayList, although the method will 

be generated to use the List interface. 

• Map - All elements in the Map must be of one of the types in this list, including other AIDL-generated 

interfaces and parcelables. Generic maps, (e.g. of the form Map are not supported. The 

actual concrete class that the other side will receive will always be a HashMap, although the method will 

be generated to use the Map interface. 

• CharSequence - This is useful for the CharSequence types used by TextView and other widget objects. 

• Other AIDL-generated interfaces, which are always passed by reference. An import statement 

is always needed for these. 

• Custom classes that implement the Parcelable protocol and are passed by value. An import 

statement t t is always needed d for these. 


9


Implementing IPC Using AIDL : Implementing the Interface 

AIDL generates an interface file for you with the same name as your .aidl file. If you are using 

the Eclipse plugin, AIDL will automatically be run as part of the build process (you don't need to 

run AIDL first and then build your project). If you are not using the plugin, you should run AIDL 

first. 

The generated interface includes an abstract inner class named Stub that declares all the 

methods that you declared in your .aidl file. Stub also defines a few helper methods, most 

notably asInterface(), which takes an IBinder (passed to a client's onServiceConnected() 

implementation when applicationContext.bindService() succeeds), and returns an instance of 

the interface used to call the IPC methods. See the section Calling an IPC Method for more 

details on how to make this cast. 

To implement your interface, extend YourInterface.Stub, and implement the methods. (You can 

create the .aidl file and implement the stub methods without building between--the Android 

build process will process .aidl files before .java files.) 

Here is an example of implementing an interface called IRemoteService, which exposes a single 

method, getPid(), using an anonymous instance: 

private final IRemoteService.Stub mBinder = new IRemoteService.Stub(){ 

public int getPid(){ 

return Process.myPid(); 

} 

} 


10


Implementing IPC Using AIDL : Exposing Your Interface to Clients 

Now that you've got your interface implementation, you need to expose it to clients. This is 

known as "publishing your service." To publish a service, inherit Service and implement 

Service.onBind(Intent) to return an instance of the class that implements your interface. Here's 

a code snippet of a service that exposes the IRemoteService interface to clients. 

public class RemoteService extends Service { 

... 

@Override 

public IBinder onBind(Intent intent) ){ 

if (IRemoteService.class.getName().equals(intent.getAction())) { return mBinder; } 

if (ISecondary.class.getName().equals(intent.getAction())) { return mSecondaryBinder; } 

return null; 

} 

private final IRemoteService.Stub mBinder = new IRemoteService.Stub() { 

public void registerCallback(IRemoteServiceCallback cb) { 

if (cb != null) mCallbacks.register(cb); 

} 

public void unregisterCallback(IRemoteServiceCallback cb) { 

if (cb != null) mCallbacks.unregister(cb); 

} 

}; 

private final ISecondary.Stub mSecondaryBinder = new ISecondary.Stub() { 

public int getPid() { return Process.myPid(); } 

public void basicTypes(int anInt, long aLong, boolean aBoolean, 

float aFloat, double aDouble, String aString) { 

} 

}; 

} 


11


Implementing IPC Using AIDL : Pass by value Parameters using Parcelables 

If you have a class that you would like to send from one process to another through an AIDL 

interface, you can do that. You must ensure that the code for your class is available to the other 

side of the IPC. Generally, that means that you're talking to a service that you started. 

There are five parts to making a class support the Parcelable protocol: 

1. Make your class implement the Parcelable interface. 

2. Implement the method public void writeToParcel(Parcel out) that takes the current state of 

the object and writes it to a parcel. 

3. Implement the method public void readFromParcel(Parcel in) that reads the value in a 

parcel into your object. 

4. Add a static field called CREATOR to your class which is an object implementing the 

Parcelable.Creator interface. 

5. Last but not least: 

• If you are developing with Eclipse/ADT, follow these steps: 

• In the Package Explorer view, right-click on the project. 

• Choose Android Tools > Create Aidl preprocess file for Parcelable classes. 

• This will create a file called "project.aidl" in the root of the project. The file will be automatically 

used when compiling an aidl file that uses the parcelable classes. 

• If you are developing with Ant or are using a custom build process, create an aidl file that declares your 

parcelable class (as shown below). If you are using a custom build process, do not add the aidl file to 

your build. Similar to a header file in C, the aidl file isn't compiled. 


12

AIDL (1.5 Change Feature) 


If you have a class that you would like to send from one process to another through an AIDL 

interface, you can do that. You must ensure that the code for your class is available to the other 

side of the IPC. Generally, that means that you're talking to a service that you started. 

There are five parts to making a class support the Parcelable protocol: 

1. Make your class implement the Parcelable interface. 

2. Implement the method public void writeToParcel(Parcel out) that takes the current state of 

the object and writes it to a parcel. 

3. Implement the method public void readFromParcel(Parcel in) that reads the value in a 

parcel into your object. 

4. Add a static field called CREATOR to your class which is an object implementing the 

Parcelable.Creator interface. 

5. Last but not least, create an aidl file that declares your parcelable class (as shown below). If 

you are using a custom build process, do not add the aidl file to your build. Similar to a 

header file in C, the aidl file isn't compiled. 


13



AIDL will use these methods and fields in the code it generates to marshall and unmarshall your 

objects. 

Here is an example of how the Rect class implements the Parcelable protocol. 

import android.os.Parcel; 

import android.os.Parcelable; 

public final class Rect implements Parcelable { 

public int left; 

public int top; 

public int right; 

public int bottom; 

public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { 

public Rect createFromParcel(Parcel in) { return new Rect(in); } 

}; 

public Rect[] newArray(int size) { return new Rect[size]; } 

public Rect() { } 

private Rect(Parcel in) { readFromParcel(in); } 

public void writeToParcel(Parcel out) { 

out.writeInt(left); 

out.writeInt(top); 

out.writeInt(right); 

out.writeInt(bottom); 

} 

public void readFromParcel(Parcel in) { 

left = in.readInt(); 

top = in.readInt(); 

right = in.readInt(); 

bottom = in.readInt(); 

} 

} 

// Rect.aidl 

package android.graphics; 

// Declare Rect so AIDL can find it and knows that it 

implements 

// the parcelable protocol. 

parcelable Rect; 


14


Calling an IPC Method 

Here are the steps a calling class should make to call your remote interface: 

1. Declare a variable of the interface type that your .aidl file defined. 

2. Implement ServiceConnection. 

3. Call Context.bindService(), passing in your ServiceConnection implementation. 

4. In your implementation of ServiceConnection.onServiceConnected(), you will receive an 

IBinder instance (called service). Call YourInterfaceName.Stub.asInterface((IBinder)service) 

to cast the returned parameter to YourInterface type. 

5. Call the methods that you defined on your interface. You should always trap 

DeadObjectException exceptions, which are thrown when the connection has broken; this 

will be the only exception thrown by remote methods. 

6. To disconnect, call Context.unbindService() with the instance of your interface. 

A few comments on calling an IPC service: 

• Objects are reference counted across processes. 

• You can send anonymous objects as method arguments. 


15


public class RemoteServiceBinding extends Activity { 

/** The primary interface we will be calling on the service. */ 

IRemoteService mService = null; 

/** Another interface we use on the service. */ 

ISecondary mSecondaryService = null; 

Calling an IPC Method : Example 

Button mKillButton; 

TextView mCallbackText; 

private boolean mIsBound; 

// Standard initialization of this activity. Set up the UI, then wait for the user to poke it before doing anything. 

@Override 

protected void onCreate(Bundle savedInstanceState) { 

} 

super.onCreate(savedInstanceState); 

setContentView(R.layout.remote_service_binding); 

// Watch for button clicks. 

Button button = (Button)findViewById(R.id.bind); 

button.setOnClickListener(mBindListener); 

button = (Button)findViewById(R.id.unbind); 

button.setOnClickListener(mUnbindListener); 

mKillButton = (Button)findViewById(R.id.kill); 

mKillButton.setOnClickListener(mKillListener); 

mKillButton.setEnabled(false); 

mCallbackText = (TextView)findViewById(R.id.callback); 

mCallbackText.setText( setText("Not attached. "); 


16


/** 

* Class for interacting with the main interface of the service. 

*/ 

private ServiceConnection mConnection =newServiceConnection() { 


public void onServiceConnected(ComponentName className,IBinder service) { 

// This is called when the connection with the service has been 

// established, giving us the service object we can use to 

// interact with the service. We are communicating with our 

// service through an IDL interface, so get a client-side 

// representation of that from the raw service object. 

mService = IRemoteService.Stub.asInterface(service); 

mKillButton.setEnabled(true); 

mCallbackText.setText( setText("Attached Attached. "); 

// We want to monitor the service for as long as we are 

// connected to it. 

try { 

mService.registerCallback(mCallback); 

i C k) 

} catch (RemoteException e) { 

} 

// In this case the service has crashed before we could even 

// do anything with it; we can count on soon being 

// disconnected (and then reconnected if it can be restarted) 

// so there is no need to do anything here. 

} 

// As part of the sample, tell the user what happened. 

Toast.makeText(RemoteServiceBinding.this, R.string.remote_service_connected, 

Toast.LENGTH_SHORT).show(); 

show(); 


17


public void onServiceDisconnected(ComponentName className) { 

// This is called when the connection with the service has been 

// unexpectedly disconnected -- that is, its process crashed. 

mService = null; 


mCallbackText.setText("Disconnected."); 


} 

}; 

// As part of the sample, tell the user what happened. 

Toast.makeText(RemoteServiceBinding.this, R.string.remote_service_disconnected, 


/** 

* Class for interacting with the secondary interface of the service. 

*/ 

private ServiceConnection mSecondaryConnection = new ServiceConnection() { 

public void onServiceConnected(ComponentName className, 

IBinder service) ){ 

// Connecting to a secondary interface is the same as any 

// other interface. 

mSecondaryService = ISecondary.Stub.asInterface(service); 

mKillButton.setEnabled(true); 

} 

public void onServiceDisconnected(ComponentName className) { 

mSecondaryService = null; 


} 

}; 


18



private OnClickListener mBindListener = new OnClickListener() { 

public void onClick(View v) { 

// Establish a couple connections with the service, binding by interface names. 

// This allows other applications to be installed that replace the remote service by implementing the same interface. 

bindService(new Intent(IRemoteService.class.getName()), mConnection, Context.BIND_AUTO_CREATE); 

bindService(new Intent(ISecondary.class.getName()), mSecondaryConnection, Context.BIND_AUTO_CREATE); 

mIsBound = true; 

mCallbackText.setText("Binding."); 

} 

}; 

private OnClickListener mUnbindListener = new OnClickListener() { 


if (mIsBound) { 

// If we have received the service, and hence registered with it, then now is the time to unregister. 

if (mService != null) { 

try { 

mService.unregisterCallback(mCallback); 


// There is nothing special we need to do if the service has crashed. 

} 

} 

} 

}; 

} 

// Detach our existing connection. 

unbindService(mConnection); 

unbindService(mSecondaryConnection); 


mIsBound = false; 

mCallbackText.setText("Unbinding."); 


19


private OnClickListener mKillListener = new OnClickListener() { 



// To kill the process hosting our service, we need to know its 

// PID. Conveniently our service has a call that will return 

// to us that information. 

if (mSecondaryService != null) { 

try { 

int pid = mSecondaryService.getPid(); 

// Note that, though this API allows us to request to kill any process based on its PID, the kernel will 

// still impose standard d restrictions ti on which h PIDs you are actually able to kill. Typically this means only 

// the process running your application and any additional processes created by that app as shown here; packages 

// sharing a common UID will also be able to kill each other's processes. 

Process.killProcess(pid); 

mCallbackText.setText("Killed service process."); 

} catch (RemoteException ex) { 

// Recover gracefully from the process hosting the server dying. 

// Just for purposes of the sample, put up a notification. 

} 

}; 

} 

} 

Toast.makeText(RemoteServiceBinding.this, 

this 

R.string.remote_call_failed, 



20


// ---------------------------------------------------------------------- 

// Code showing how to deal with callbacks. 

// ---------------------------------------------------------------------- 


// This implementation is used to receive callbacks from the remote service. 

private IRemoteServiceCallback mCallback = new IRemoteServiceCallback.Stub() { 

/** 

* This is called by the remote service regularly to tell us about 

* new values. Note that IPC calls are dispatched through a thread 

* pool running in each process, so the code executing here will 

* NOT be running in our main thread like most other things -- so, 

* to update the UI, we need to use a Handler to hop over there. 

*/ 

public void valueChanged(int value) { 

mHandler.sendMessage(mHandler.obtainMessage(BUMP_MSG, MSG value, 0)); 

} 

}; 

private static final int BUMP_MSG = 1; 

private Handler mHandler = new Handler() { 

@Override public void handleMessage(Message msg) { 

switch (msg.what) { 

case BUMP_MSG: 

mCallbackText.setText("Received from service: " + msg.arg1); 

break; 

default: 

super.handleMessage(msg); 

} 

} 

} 

}; 


21

Parcel : Definition 

Container for a message (data and object references) that can be sent through an IBinder. A 

Parcel can contain both flattened data that will be unflattened on the other side of the IPC (using 

the various methods here for writing specific types, or the general Parcelable interface), and 

references to live IBinder objects that will result in the other side receiving a proxy IBinder 

connected with the original IBinder in the Parcel. 

Parcel is not a general-purpose serialization mechanism. This class (and the 

corresponding Parcelable API for placing arbitrary objects into a Parcel) is designed as a 

high-performance IPC transport. As such, it is not appropriate to place any Parcel data in 

to persistent storage: changes in the underlying implementation of any of the data in the 

Parcel can render older data unreadable. 

The bulk of the Parcel API revolves around reading and writing data of various types. There are 

six major classes of such functions available. 


22

Parcel : Primitives 

The most basic data functions are for writing and reading primitive data types: 

writeByte(byte), readByte(), 

writeDouble(double), readDouble(), 

writeFloat(float), readFloat(), 

writeInt(int), readInt(), 

writeLong(long), readLong(), 

writeString(String), readString(). 

Most other data operations are built on top of these. The given data is written and read using 

the endianess of the host CPU. 


23

Parcel : Primitive Arrays 

There are a variety of methods for reading and writing raw arrays of primitive objects, which 

generally result in writing a 4-byte length followed by the primitive data items. The methods for 

reading can either read the data into an existing array, or create and return a new array. These 

available types are: 

writeBooleanArray(boolean[]), readBooleanArray(boolean[]), createBooleanArray() 

writeByteArray(byte[]), writeByteArray(byte[], int, int), readByteArray(byte[]), createByteArray() 

writeCharArray(char[]), readCharArray(char[]), createCharArray() 

writeDoubleArray(double[]), readDoubleArray(double[]), createDoubleArray() 

writeFloatArray(float[]), readFloatArray(float[]), createFloatArray() 

writeIntArray(int[]), readIntArray(int[]), createIntArray() 

writeLongArray(long[]), readLongArray(long[]), createLongArray() 

writeStringArray(String[]), readStringArray(String[]), createStringArray(). 

writeSparseBooleanArray(SparseBooleanArray), readSparseBooleanArray(). 


24

Parcel : Parcelables 

The Parcelable protocol provides an extremely efficient (but low-level) protocol for objects to 

write and read themselves from Parcels. You can use the direct methods 

writeParcelable(Parcelable, int) and readParcelable(ClassLoader) or writeParcelableArray(T[], 

int) and readParcelableArray(ClassLoader) to write or read. These methods write both the class 

type and its data to the Parcel, allowing that class to be reconstructed from the appropriate 

class loader when later reading. 

There are also some methods that provide a more efficient way to work with Parcelables: 

writeTypedArray(T[], int), writeTypedList(List), readTypedArray(T[], Parcelable.Creator) and 

readTypedList(List, Parcelable.Creator). These methods do not write the class information of 

the original object: instead, the caller of the read function must know what type to expect and 

pass in the appropriate Parcelable.Creator instead to properly construct the new object and 

read its data. (To more efficient write and read a single Parceable object, you can directly call 

Parcelable.writeToParcel and Parcelable.Creator.createFromParcel yourself.) 


25

Parcel : Bundles 

A special type-safe container, called Bundle, is available for key/value maps of heterogeneous 

values. This has many optimizations for improved performance when reading and writing data, 

and its type-safe API avoids difficult to debug type errors when finally marshalling the data 

contents into a Parcel. 

The methods to use are 

writeBundle(Bundle), 

readBundle(), and 

readBundle(ClassLoader). 


26

Parcel : Activie Objects 

An unusual feature of Parcel is the ability to read and write active objects. For these objects the 

actual contents of the object is not written, rather a special token referencing the object is 

written. When reading the object back from the Parcel, you do not get a new instance of the 

object, but rather a handle that operates on the exact same object that was originally written. 

There are two forms of active objects available. 

Binder objects are a core facility of Android's general cross-process communication system. 

The IBinder interface describes an abstract protocol with a Binder object. Any such interface 

can be written in to a Parcel, and upon reading you will receive either the original object 

implementing that interface or a special proxy implementation that communicates calls back to 

the original object. The methods to use are writeStrongBinder(IBinder), 

writeStrongInterface(IInterface), readStrongBinder(), writeBinderArray(IBinder[]), 

readBinderArray(IBinder[]), createBinderArray(), writeBinderList(List), readBinderList(List), 

createBinderArrayList(). 

FileDescriptor objects, representing raw Linux file descriptor identifiers, can be written and 

ParcelFileDescriptor objects returned to operate on the original file descriptor. The returned file 

descriptor is a dup of the original file descriptor: the object and fd is different, but operating on 

the same underlying file stream, with the same position, etc. The methods to use are 

writeFileDescriptor(FileDescriptor), readFileDescriptor(). 


27

Parcel : Activie Objects (Binder) 

Process A 

Process B 

App A 

Context 

Binder 

Service B 

get Service 

service 

call foo(object) 

marshal proxy 

object 

relay to 

IPC threads 

call return 


28

Parcel : Activie Objects (FileDescriptor) 

protected final ParcelFileDescriptor openFileHelper(Uri uri, String mode) throws FileNotFoundException { 

Cursor c = query(uri, new String[]{"_data"}, null, null, null); 

int count = (c != null) ? c.getCount() : 0; 

if (count != 1) { 

// If there is not exactly one result, throw an appropriate 

// exception. 

if (c != null) { 

cclose(); c.close(); 

} 

if (count == 0) { 

throw new FileNotFoundException("No entry for " + uri); 

} 

throw new FileNotFoundException("Multiple ti lti l items at " + uri); 

} 

c.moveToFirst(); 

int i = c.getColumnIndex("_data"); 

(_ String path = (i >= 0 ? c.getString(i) : null); 

c.close(); 

if (path == null) { 

throw new FileNotFoundException("Column _data not found."); 

} 

} 

int modeBits = ContentResolver.modeToMode(uri, mode); 

return ParcelFileDescriptor.open(new File(path), modeBits); 


29


public final OutputStream openOutputStream(Uri uri) 

throws FileNotFoundException { 

return openOutputStream(uri, "w"); 

} 

public final OutputStream openOutputStream(Uri uri, String mode) 

throws FileNotFoundException { 

AssetFileDescriptor fd = openAssetFileDescriptor(uri, p ( mode); 

try { 

return fd != null ? fd.createOutputStream() : null; 

} catch (IOException e) { 

throw new FileNotFoundException("Unable to create stream"); 

} 

} 


30


public final AssetFileDescriptor openAssetFileDescriptor(Uri uri, String mode) throws FileNotFoundException { 

String scheme = uri.getScheme(); 

if (SCHEME_ANDROID_RESOURCE.equals(scheme)) { /* … 생략 … } 

else if (SCHEME_FILE.equals(scheme)) { /* … 생략 … } 

else { 

IContentProvider provider = acquireProvider(uri); 

if (provider == null) { /* … 생략 … */ } 

try { 

AssetFileDescriptor fd = provider.openAssetFile(uri, mode); 

if(fd == null) { /* … 생략 … */ } 

ParcelFileDescriptor pfd = new ParcelFileDescriptorInner(fd.getParcelFileDescriptor(), provider); 

return new AssetFileDescriptor(pfd, fd.getStartOffset(),fd.getDeclaredLength()); 

getDeclaredLength()); 

} 


releaseProvider(provider); 

throw new FileNotFoundException("Dead content provider: " + uri); 

} catch (FileNotFoundException e) { 


throw e; 

} catch (RuntimeException e) { 


throw e; 

} 

} 


31

Parcel : Untyped Containers 

Untyped Containers 

A final class of methods are for writing and reading standard Java containers of arbitrary types. 

These all revolve around the writeValue(Object) and readValue(ClassLoader) methods which 

define the types of objects allowed. 

The container methods are 

writeArray(Object[]), 

readArray(ClassLoader), 

writeList(List), 

readList(List, ClassLoader), 

readArrayList(ClassLoader), 

writeMap(Map), 

p), 

readMap(Map, ClassLoader), 

writeSparseArray(SparseArray), 

readSparseArray(ClassLoader). 


32

Parcel : Rect Example 

import android.os.Parcel; 

import android.os.Parcelable; 

public final class Rect implements Parcelable { 

public int left; 

public int top; 

public int right; 

public int bottom; 

public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { 

public Rect createFromParcel(Parcel in) { return new Rect(in); } 

public Rect[] newArray(int size) { return new Rect[size]; } 

}; 

public Rect() { } 

private Rect(Parcel in) { readFromParcel(in); } 

public void writeToParcel(Parcel out) { 

out.writeInt(left); 

out.writeInt(top); 

out.writeInt(right); 

out.writeInt(bottom); 

} 

} 

public void readFromParcel(Parcel in) { 

left = in.readInt(); 

top = in.readInt(); 

right = in.readInt(); 

bottom = in.readInt(); 

} 


33

Parcel : Rect Example (Basic (Intent) → Advanced (AIDL) ) 

Intent i = new Intent(); 

ComponentName comp = 

new ComponentName("org.kandroid.testApp", 

pp "org.kandroid.testApp.MyNextActivity"); 

i.setComponent(comp); 

Rect rect = new Rect(); 

rect.left =1; 

rect.right = 2; 

rect.bottom = 3; 

rect.top = 4; 

i.putExtra("parcelableContent", t t t" rect); 

startActivity(i); 

Intent intent = getIntent(); 

Rect rect 

= (Rect) intent.getParcelableExtra("parcelableContent"); 

TextView tvTop = (TextView)findViewById(R.id.top); 

TextView tvBottom = (TextView)findViewById(R.id.bottom); 

TextView tvLeft = (TextView)findViewById(R.id.left); 

TextView tvRight =(TextView)findViewById(R (TextView)findViewById(R.id.right); id tvTop.setText(Integer.toString(rect.top)); 

tvBottom.setText(Integer.toString(rect.bottom)); 

tvLeft.setText(Integer.toString(rect.left)); 

tvRight.setText(Integer.toString(rect.right)); 

tT t(I t t i ( t i ht)) 


34

android.content.Context 

android.content 

Contains classes for accessing and publishing data on the device. It includes three main 

categories of APIs: the Resources for retrieving resource data associated with an application; 

Content Providers and ContentResolver for managing and publishing persistent data associated 

with an application; and the Package Manager for finding out information about the application 

packages installed on the device. 

In addition, the Context abstract class is a base API for pulling these pieces together, 

allowing you to access an application's resources and transfer data between applications. 

android.content.Context 

This package builds on top of the lower-level Android packages android.database, android.text, 

android.graphics.drawable, android.graphics, android.os, and android.util. 

Interface to global information about an application environment. 

This is an abstract class whose implementation is provided by the Android system. 

It allows access to application-specific resources and classes, as well as up-calls for applicationlevel 

operations such as launching activities, broadcasting and receiving intents, etc. 


35

android.content.Context : Public Methods 

bindService 

… 

checkUriPermission 

clearWallpaper 

createPackageContext 

databaseList 

deleteDatabase 

deleteFile 

… 

enforceUriPermission 

fileList 

getApplicationContext 

getAssets 

getCacheDir 

getClassLoader 

getContentResolver 

getDatabasePath 

getDir 

… 

getMainLooper 

getPackageManager 

g g 

getPackageName 

getResource 

getPackageName 

getResource 

getSharedPreferences 

getString 

getSystemService 

getText 

getTheme 

getWallpaper 

… 

grantUriPermission 

obtainStyledAttributes 

openFileInput 

openFileOutput 

openOrCreateDatabase 

peekWallper 

registerReceiver 

removeStickyBroadcast 

revokeUriPermission 

sendBroadcast 

… 

setTheme 

setWallpaper 

startActivity 

startInstrumentation 

startService 

stopService 

unbindService 

unregisterReceiver 


36

Android Start-up (Review) 

Zygote 

App. Framework 

• System Services 

• Hardware Services 

Dalvik VM 

Home 

Dalvik VM 

? 

Native Server 

• Audio Flinger 

• Surface Flinger 

daemons 

• usbd 

• adbd 

• debuggerd 

• rild 

Service 

Manager 

runtime 

Zygote 

libc libc libc 

Init 

Kernel 

Binder Driver 

System Server 

libc 

Home 

libc 

zygote란 애플리케이션을 빠르게 구동하기 위해서 미 

리 fork 되어 있는 프로세스이다. 

이것은 시스템에서 exec() 호출을 통해 특정 애플리케 

이션을 실행하고자 하기 전까지는 중립적인 상태, 즉 

특정 애플리케이션과 합체되지 않는 상태를 유지한다. 


37

Android Service List : service list 

phone: [com.android.internal.telephony.ITelephony] 

hardware: [android.os.IHardwareService] 

iphonesubinfo: [com.android.internal.telephony.IPhoneSubInfo] battery: [] 

simphonebook: [com.android.internal.telephony.IIccPhoneBook] 

i t l content: t [android.content.IContentService] 

t t tS i isms: [com.android.internal.telephony.ISms] 

account: [android.accounts.IAccountManager] 

appwidget: [com.android.internal.appwidget.IAppWidgetService] permission: [android.os.IPermissionController] 

backup: [android.backup.IBackupManager] 

activity.providers: [] 

audio: [android.media.IAudioService] 

activity.senders: [] 

wallpaper: [android.app.IWallpaperManager] 

activity.services: [] 

checkin: [android.os.ICheckinService] 

activity.broadcasts: [] 

search: [android.app.ISearchManager] 

cpuinfo: [] 

location: [android.location.ILocationManager] 

meminfo: [] 

devicestoragemonitor: [] 

activity: [android.app.IActivityManager] 

mount: [android.os.IMountService] 

package: [android.content.pm.IPackageManager] 

notification: [android.app.INotificationManager] 

telephony.registry: 

accessibility: [android.view.accessibility.IAccessibilityManager] [com.android.internal.telephony.ITelephonyRegistry] 

connectivity: [android.net.IConnectivityManager] 

usagestats: [com.android.internal.app.IUsageStats] 

wifi: [android.net.wifi.IWifiManager] 

batteryinfo: [com.android.internal.app.IBatteryStats] 

netstat: [android.os.INetStatService] 

power: [android.os.IPowerManager] 

input_method: [com.android.internal.view.IInputMethodManager] entropy: [] 

clipboard: [android.text.IClipboard] 

SurfaceFlinger: [android.ui.ISurfaceComposer] 

statusbar: [android.app.IStatusBar] 

media.audio_policy: [android.media.IAudioPolicyService] 

window: [android.view.IWindowManager] 

media.camera: [android.hardware.ICameraService] 

sensor: [android.hardware.ISensorService] 

media.player: [android.media.IMediaPlayerService] 

alarm: [android.app.IAlarmManager] 

app media.audio_flinger: a dio [android.media.IAudioFlinger] 

dioFlinger] 


38

질의및응답 

Q & A 


39


AndroidManifest.xml 


The AndroidManifest.xml File 


Every application must have an AndroidManifest.xml file (with precisely that name) in its root 

directory. The manifest presents essential information about the application to the Android system, 

information the system must have before it can run any of the application's code. Among other 

things, the manifest does the following: 


41


• It names the Java package for the application. The package name serves as a unique identifier for 

the application. 

• It describes the components of the application - the activities, services, broadcast receivers, and 

content providers that the application is composed of. It names the classes that implement each of the 

components and publishes their capabilities (for example, which Intent messages they can handle). 

These declarations a let the Android d system know what the components are and under what conditions 

o they can be launched. 

• It determines which processes will host application components. 

• It declares which permissions the application must have in order to access protected parts of 

the API and interact with other applications. 

• It also declares. the permissions that others are required to have in order to interact with the 

application's components 

• It lists the Instrumentation classes that provide profiling and other information as the 

application is running. These declarations are present in the manifest only while the application is 

being developed and tested; they're removed before the application is published. 

• It declares the minimum level of the Android API that the application requires. 

• It lists the libraries that the application must be linked against. 


42


 

 

 

 

 

 

 

Structure of the Manifest File 

API Level 3 

API Level 4 

 

 

 

 

 

t .. t 

 

 

.. 

 

 

.. 

 

 

API Level 4 

 

permission> 

 

 

 

 

 


43


File Conventions 

Elements 

Only the and elements are required, they each must be present 

and can occur only once. Most of the others can occur many times or not at all - although at 

least some of them must be present for the manifest to accomplish anything meaningful. 

If an element contains anything at all, it contains other elements. All values are set through 

attributes, not as character data within an element. 

Elements at the same level are generally not ordered. 

For example, , , and elements can be intermixed in any sequence. 

(An alias> element is the exception to this rule: It must follow the it is an 

alias for.) 


44


File Conventions 

Attributes 

In a formal sense, all attributes are optional. However, there are some that must be specified for 

an element to accomplish its purpose. Use the documentation as a guide. For truly optional 

attributes, it mentions a default value or states what happens in the absence of a specification. 

Except for some attributes of the root element, all attribute names begin with an 

android: prefix - for example, android:alwaysRetainTaskState. Because the prefix is universal, the 

documentation generally omits it when referring to attributes by name. 


45


Declaring class names 

Many elements correspond to Java objects, including elements for the application itself (the 

element) and its principal components - activities (), services (), 

broadcast receivers (), and content providers (). 

If you define a subclass, as you almost always would for the component classes (Activity, Service, 

BroadcastReceiver, and ContentProvider), the subclass is declared through a name attribute. The 

name must include the full package designation. 

 

 

 

. . . 

 

. . . 

 

 


46


However, as a shorthand, if the first character of the string is a period, the string is appended to the 

application's package name (as specified by the element's package attribute). 

 

 

 

. . . 

 

. . . 

 

 

When starting a component, Android creates an instance of the named subclass. If a subclass isn't 

specified, it creates an instance of the base class. 


47


Multiple values 

If more than one value can be specified, the element is almost always repeated, rather than listing 

multiple values within a single element. For example, an intent filter can list several actions: 

 

 

 

 

. . . 

 


48


Resource values 

Some attributes have values that can be displayed to users - for example, a label and an icon 

for an activity. The values of these attributes should be localized and therefore set from a 

resource or theme. Resource values are expressed in the following format, 

@[package:]type:name 

where the package name can be omitted if the resource is in the same package as the 

application, type is a type of resource - such as "string" or "drawable" - and name is the name 

that identifies the specific resource. For example: 

 

Values from a theme are expressed in a similar manner, but with an initial '?' rather than '@': 

?[package:]type:name 

String values 

Where an attribute value is a string, double backslashes ('\\') must be used to escape 

characters - for example, '\\n' foranewlineor'\\uxxxx' for a Unicode character. 


49


File Features 

Intent Filters 

The core components of an application (its activities, services, and broadcast receivers) are 

activated by intents. An intent is a bundle of information (an Intent object) describing a desired 

action - including the data to be acted upon, the category of component that should perform the 

action, and other pertinent instructions. Android locates an appropriate component to respond to the 

intent, launches a new instance of the component if one is needed, and passes it the Intent object. 

Components advertise their capabilities - the kinds of intents they can respond to - through intent 

filters. Since the Android system must learn which intents a component can handle before it 

launches the component, intent filters are specified in the manifest as elements. A 

component may have any number of filters, each one describing a different capability. 

An intent that explicitly names a target component will activate that component; the filter doesn't 

play a role. But an intent that doesn't specify a target by name can activate a component only if it 

can pass through one of the component's filters. 

For information on how Intent objects are tested against intent filters, see a separate document, 

Intents and Intent Filters. 


50


Icons and Labels 

A number of elements have icon and label attributes for a small icon and a text label that can 

be displayed to users. Some also have a description attribute for longer explanatory text that 

can also be shown on-screen. For example, the element has all three of these 

attributes, so that when the user is asked whether to grant the permission to an application that has 

requested it, an icon representing the permission, the name of the permission, and a description of 

what it entails can all be presented to the user. 

In every case, the icon and label set in a containing element become the default icon and 

label settings for all of the container's subelements. Thus, the icon and label set in the 

element are the default icon and label for each of the application's components. 

Similarly, the icon and label set for a component - for example, an element - are the 

default settings for each of the component's elements. If an element 

sets a label, but an activity and its intent filter do not, the application label is treated as the label for 

both the activity and the intent filter. 

The icon and label set for an intent filter are used to represent a component whenever the 

component is presented to the user as fulfilling the function advertised by the filter. For 

example, a filter with "android.intent.action.MAIN" and "android.intent.category.LAUNCHER" 

settings advertises an activity as one that initiates an application - that is, as one that should be 

displayed in the application launcher. The icon and label set in the filter are therefore the ones 

displayed in the launcher. 


51

The AndroidManifest.xml File : permission 

Permissions 

A permission is a restriction limiting access to a part of the code or to data on the device. The 

limitation is imposed to protect critical data and code that could be misused to distort or damage the 

user experience. 

Each permission is identified ed by a unique label. Often the label indicates the action that's restricted. 

ed 

For example, here are some permissions defined by Android: 

android.permission.CALL_EMERGENCY_NUMBERS 

android.permission.READ _ OWNER_ 

DATA 

android.permission.SET_WALLPAPER 

android.permission.DEVICE_POWER 

A feature can be protected by at most one permission. 

If an application needs access to a feature protected by a permission, it must declare that it requires 

that permission with a element in the manifest. Then, when the application is 

installed on the device, the installer determines whether or not to grant the requested 

permission by checking the authorities that signed the application's certificates and, in some 

cases, asking the user. If the permission is granted, the application is able to use the protected 

features. If not, its attempts to access those features will simply fail without any notification to the user. 


52


> pm list permissions –s 

Network communication: 

view Wi-Fi state, create Bluetooth connections, full Internet access, view network state 

Your location: 

access extra location provider commands, fine (GPS) location, 

mock location sources for testing, coarse (network-based) location 

Your Google accounts: 

Android services, Google Checkout QA accounts, Google Book Search, 

view configured accounts, discover known accounts, access other Google services, 

Google Base, Google WiFi, YouTube usernames, Google Calendar, 

contacts data in Google accounts, Dodgeball, Google Checkout accounts, 

YouTube, Google Notebook, access all Google services, JotSpot, Knol, AdWords, 

AdSense, Android services, Blogger, Google Health, Google Spreadsheets, 

Google Talk, Google mail, Google Maps, Google Docs, Picasa Web Albums, Google News, 

Google Webmaster Tools, iGoogle accounts, Orkut, Google mobile applications, 

Google App Engine, Google Checkout Sandbox accounts, Google Finance, Google Groups 


53


Phone calls: 

intercept outgoing calls, read phone state, modify phone state 

Development tools: 

limit number of running processes, make all background applications close, 

send Linux signals to applications, enable application debugging 

System tools: 

set preferred applications, measure application storage space, display system-level alerts, 

write Access Point Name settings, retrieve system internal state, uninstall shortcuts, 

send package removed broadcast, write subscribed feeds, modify global animation speed, 

automatically start at boot, change Wi-Fi state, make application always run, 

read system log files, restart other applications, disable keylock, send sticky broadcast, 

write sync settings, read sync settings, prevent phone from sleeping, 

expand/collapse status bar, mount and unmount filesystems, change your UI settings, 

reorder running applications, set wallpaper size hints, delete all application cache data, 

set time zone, modify global system settings, read sync statistics, 

retrieve running applications, set wallpaper, read subscribed feeds, install shortcuts, 

read/write to resources owned by diag, change network connectivity, bluetooth administration 


54


Your messages: 

send WAP-PUSH-received broadcast, receive WAP, read Email attachments, 

read SMS or MMS, send SMS-received broadcast, edit SMS or MMS, receive SMS, 

write instant messages, read instant messages, receive MMS 

Services that cost you money: 

send SMS messages, directly call phone numbers 

Hardware controls: 

control vibrator, test hardware, take pictures, control flashlight, 

change your audio settings, record audio 

Your personal information: 

write contact data, read calendar data, write owner data, read contact data, 

read owner data, write calendar data 


55


ungrouped: 

Send download notifications., run in factory test mode, monitor and control all 

application launching, delete other applications' data, Access download manager., 

directly call any phone numbers, force application to close, access checkin properties, 

control location update notifications, read frame buffer, display unauthorized windows, 

Download OTA update., publish low-level services, press keys and control buttons, 

reset system to factory defaults, Access DRM content., disable or modify status bar, 

modify battery statistics, directly install applications, manage application tokens, 

keep from being stopped, access SurfaceFlinger, 

enable or disable application components, Access download data., 

record what you type and actions you take, delete applications, 

access to passwords for Google accounts, permanently disable phone, 

Use system cache., modify the Google services map, force phone reboot, 

delete other applications' caches, automatically install system updates, 

change screen orientation, select Gmail or Google Mail branding, power phone on or off 


56


# pm list permissions 

pm list permissions 

All Permissions: 

permission:android.permission.SEND_DOWNLOAD_COMPLETED_INTENTS 

permission:android.permission.FACTORY_TESTTEST 

permission:android.permission.SET_ACTIVITY_WATCHER 

permission:android.permission.SET_PROCESS_FOREGROUND 

permission:android.permission.ACCESS_SURFACE_FLINGER 

permission:android.permission.CHANGE p _ COMPONENT_ ENABLED_ 

STATE 

permission:android.permission.ACCESS_DOWNLOAD_DATA 

permission:android.permission.READ_INPUT_STATE 

… 

permission:org.kandroid.helloandroid.KANDROID 

permission:android.permission.ACCESS_CACHE_FILESYSTEM 

permission:android.permission.WRITE_GSERVICES 

permission:android.permission.REBOOT 

permission:android.permission.DELETE p _ CACHE_ 

FILES 

permission:android.permission.FOTA_UPDATE 

permission:android.permission.SET_ORIENTATION 

permission:com.google.android.googleapps.permission.GOOGLE_MAIL_SWITCH 

permission:android.permission.DEVICE p _ POWER 


57


An application can also protect its own components (activities, services, broadcast receivers, 

and content providers) with permissions. It can employ any of the permissions defined by 

Android (listed in android.Manifest.permission) or declared by other applications. Or it 

can define its own. 

A new permission is declared with the element. For example, an activity could 

be protected as follows: 

 

 

. . . 

 

 

android:permission="com.example.project.DEBIT p p j _ ACCT" 

. . . > 

. . . 

 

 

. . . 

 

. . . 

 


58


Note that, in this example, the DEBIT_ACCT permission is not only declared with the 

element, its use is also requested with the element. Its use 

must be requested in order for other components of the application to launch the protected 

activity, even though the protection is imposed by the application itself. 

If, in the same example, the permission attribute was set to a permission declared 

elsewhere (such as android.permission.CALL_EMERGENCY_NUMBERS, it would not have 

been necessary to declare it again with a element. However, it would still 

have been necessary to request its use with . 

The element declares a namespace for a group of permissions that will 

be defined in code. 

And defines a label for a set of permissions (both those declared in the 

manifest with elements and those declared elsewhere). It affects only how the 

permissions are grouped when presented to the user. The element does 

not specify which permissions belong to the group; it just gives the group a name. A 

permission is placed in the group by assigning the group name to the 

element's permissionGroup attribute. 


59


ACCESS_CHECKIN_PROPERTIES 

ACCESS_COARSE_LOCATION 

ACCESS_FINE_LOCATION 

ACCESS_LOCATION_EXTRA_COMMANDS 

ACCESS_MOCK_LOCATION 

ACCESS_NETWORK_STATE 

ACCESS_SURFACE_FLINGER 

ACCESS_WIFI_STATE 

ADD_SYSTEM_SERVICE 

BATTERY_STATS 

BLUETOOTH 

BLUETOOTH_ADMIN 

BRICK 

BROADCAST_PACKAGE_REMOVED 

BROADCAST_SMS 

BROADCAST_STICKY 

BROADCAST_WAP_PUSH 

CALL_PHONE 

CALL_PRIVILEGED 

Allows read/write access to the "properties" table in the checkin database, to change values that 

get uploaded. 

Allows an application to access coarse (e.g., Cell-ID, WiFi) location 

Allows an application to access fine (e.g., GPS) location 

Allows an application to access extra location provider commands 

Allows an application to create mock location providers for testing 

Allows applications to access information about networks 

Allows an application to use SurfaceFlinger's low level features 

Allows applications to access information about Wi-Fi networks 

Allows an application to publish system-level services. 

Allows an application to update the collected battery statistics 

Allows applications to connect to paired bluetooth devices 

Allows applications to discover and pair bluetooth devices 

Required to be able to disable the device (very dangerous!). 

Allows an application to broadcast a notification that an application package has been removed. 

Allows an application to broadcast an SMS receipt notification 

Allows an application to broadcast sticky intents. 

Allows an application to broadcast a WAP PUSH receipt notification 

Allows an application to initiate a phone call without going through the Dialer user interface for 

the user to confirm the call being placed. 

Allows an application to call any phone number, including emergency numbers, without going 

through the Dialer user interface for the user to confirm the call being placed. 


60


CAMERA 

CHANGE_COMPONENT_ENABLED_STATECOMPONENT ENABLED CHANGE_CONFIGURATION 

CHANGE_NETWORK_STATE 

CHANGE_WIFI_STATE 

CLEAR_APP_CACHE 

CLEAR_APP_USER_DATA 

CONTROL_LOCATION_UPDATES 

DELETE_CACHE_FILES 

DELETE_PACKAGES 

DEVICE_POWER 

DIAGNOSTIC 

DISABLE_KEYGUARD 

DUMP 

EXPAND_STATUS_BAR 

FACTORY_TEST 

FLASHLIGHT 

FORCE_BACK 

FOTA_UPDATE 

GET_ACCOUNTS 

Required to be able to access the camera device. 

Allows an application to change whether an application component (other than its own) is 

enabled or not. 

Allows an application to modify the current configuration, such as locale. 

Allows applications to change network connectivity state 

Allows applications to change Wi-Fi connectivity state 

Allows an application to clear the caches of all installed applications on the device. 

Allows an application to clear user data 

Allows enabling/disabling location update notifications from the radio. 

Allows an application to delete cache files. 

Allows an application to delete packages. 

Allows low-level access to power management 

Allows applications to RW to diagnostic resources. 

Allows applications to disable the keyguard 

Allows an application to retrieve state dump information from system services. 

Allows an application to expand or collapse the status bar. 

Run as a manufacturer test application, running as the root user. 

Allows access to the flashlight 

Allows an application to force a BACK operation on whatever is the top activity. 

Allows access to the list of accounts in the Accounts Service 


61


GET_PACKAGE_SIZE 

GET_TASKSTASKS 

HARDWARE_TEST 

INJECT_EVENTS 

INSTALL_PACKAGES 

INTERNAL_SYSTEM_WINDOW 

INTERNET 

Allows an application to find out the space used by any package. 

Allows an application to get information about the currently or recently running tasks: a 

thumbnail representation of the tasks, what activities are running in it, etc. 

Allows access to hardware peripherals. 

Allows an application to inject user events (keys, touch, trackball) into the event stream and 

deliver them to ANY window. 

Allows an application to install packages. 

Allows an application to open windows that are for use by parts of the system user interface. 

Allows applications to open network sockets. 

MANAGE_APP_TOKENSAPP Allows an application to manage (create, destroy, Z-order) application tokens in the window 

manager. 

MASTER_CLEAR 

MODIFY_AUDIO_SETTINGS 

MODIFY_PHONE_STATE 

MOUNT_UNMOUNT_FILESYSTEMS 

PERSISTENT_ACTIVITY 

PROCESS_OUTGOING_CALLS 

READ_CALENDAR 

READ_CONTACTS 

READ_FRAME_BUFFER 

READ_INPUT_STATE 

READ_LOGS 

Allows an application to modify global audio settings 

Allows modification of the telephony state - power on, mmi, etc. 

Allows mounting and unmounting file systems for removable storage. 

Allow an application to make its activities persistent. 

Allows an application to monitor, modify, or abort outgoing calls. 

Allows an application to read the user's calendar data. 

Allows an application to read the user's contacts data. 

Allows an application to take screen shots and more generally get access to the frame buffer 

data 

Allows an application to retrieve the current state of keys and switches. 

Allows an application to read the low-level system log files. 


62


READ_OWNER_DATA 

READ_PHONE_STATE 

READ_SMS 

READ_SYNC_SETTINGS 

READ_SYNC_STATS 

REBOOT 

RECEIVE_BOOT_COMPLETED 

RECEIVE_MMS 

RECEIVE_SMS 

RECEIVE_WAP_PUSH 

RECORD_AUDIO 

REORDER_TASKS 

RESTART_PACKAGES 

SEND_SMS 

SET_ACTIVITY_WATCHER 

SET_ALWAYS_FINISH 

Allows an application to read the owner's data. 

Allows read only access to phone state. 

Allows an application to read SMS messages. 

Allows applications to read the sync settings 

Allows applications to read the sync stats 

Required to be able to reboot the device. 

Allows an application to receive the ACTION_BOOT_COMPLETED that is broadcast after the 

system finishes booting. 

Allows an application to monitor incoming MMS messages, to record or perform processing on 

them. 

Allows an application to monitor incoming SMS messages, to record or perform processing on 

them. 

Allows an application to monitor incoming WAP push messages. 

Allows an application to record audio 

Allows an application to change the Z-order of tasks 

Allows an application to restart other applications. 

Allows an application to send SMS messages. 

SET_ ANIMATION_ SCALE 

Modify the global animation scaling factor. 

SET_DEBUG_APP 

Allows an application to watch and control how activities are started globally in the system. 

Allows an application to control whether activities are immediately finished when put in the 

background. 

Configure an application for debugging. 


63


SET_ORIENTATION 

SET_PREFERRED_APPLICATIONS 

SET_PROCESS_FOREGROUND 

SET_PROCESS_LIMIT 

SET_TIME_ZONE 

SET_WALLPAPER 

Allows low-level access to setting the orientation (actually rotation) of the screen. 

Allows an application to modify the list of preferred applications with the 

PackageManager.addPackageToPreferred() and 

PackageManager.removePackageFromPreferred() methods. 

Allows an application to force any currently running process to be in the foreground. 

Allows an application to set the maximum number of (not needed) application processes that 

can be running. 

Allows applications to set the system time zone 

Allows applications to set the wallpaper 

SET_WALLPAPER_HINTS 

_ Allows applications to set the wallpaper p hints 

SIGNAL_PERSISTENT_PROCESSES 

STATUS_BAR 

SUBSCRIBED_FEEDS_READ 

SUBSCRIBED_FEEDS_WRITE 

SYSTEM_ALERT_WINDOW 

VIBRATE 

WAKE_LOCK 

WRITE_APN_SETTINGS 

WRITE_CALENDAR 

WRITE_CONTACTS 

Allow an application to request that a signal be sent to all persistent processes 

Allows an application to open, close, or disable the status bar and its icons. 

Allows an application to allow access the subscribed feeds ContentProvider. 

Allows an application to open windows using the type TYPE_SYSTEM_ALERT, shown on top 

of all other applications. 

Allows access to the vibrator 

Allows using PowerManager WakeLocks to keep processor from sleeping or screen from 

dimming 

Allows applications to write the apn settings 

Allows an application to write (but not read) the user's calendar data. 

Allows an application to write (but not read) the user's contacts data. 


64


WRITE_GSERVICES 

WRITE_OWNER_DATA 

WRITE_SETTINGS 

WRITE_SMS 

WRITE_SYNC_SETTINGS 

Allows an application to modify the Google service map. 

Allows an application to write (but not read) the owner's data. 

Allows an application to read or write the system settings. 

Allows an application to write SMS messages. 

Allows applications to write the sync settings 


65


# cat /system/etc/permissions.xml 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


66

The AndroidManifest.xml File : library 

Libraries 

Every application is linked against the default Android library, which h includes the basic packages 

for building applications (with common classes such as Activity, Service, Intent, View, Button, 

Application, ContentProvider, and so on). 

However, some packages reside in their own libraries. i If your application uses code from any of 

these packages, it must explicitly asked to be linked against them. The manifest must contain a 

separate element to name each of the libraries. (The library name can be found 

in the documentation for the package.) 


67


 

8? 

 

 

 

 

 

 

 

 

 

 

 

 

 


68


 

8? 

 

 

 

 


69


public class NooYawk extends MapActivity { 

private MapView map=null; 

private MyLocationOverlay me=null; 

@Override 

public void onCreate(Bundle savedInstanceState) { 

super.onCreate(savedInstanceState); 

ea e(sa ed s a a e); 

setContentView(R.layout.main); 

map=(MapView)findViewById(R.id.map); 

p ( p); 

} 

} 

map.getController().setCenter(getPoint(40.76793169992044,-73.98180484771729)); 

map.getController().setZoom(17); 

ViewGroup zoom=(ViewGroup)findViewById(R.id.zoom); 

( ); 

zoom.addView(map.getZoomControls()); 

Drawable marker=getResources().getDrawable(R.drawable.marker); 

marker.setBounds(0, 0, marker.getIntrinsicWidth(), 

marker.getIntrinsicHeight()); 

g map.getOverlays().add(new SitesOverlay(marker)); 

me=new MyLocationOverlay(this, map); 

map.getOverlays().add(me); 


70



71

The AndroidManifest.xml File : library (old signing method) 

> "c:\Program Files\Java\jdk1.6.0_10\bin\keytool.exe" 

-genkey -keystore kandroid_keystore –validity 10000 -alias kandroid_key 

keystore 암호를 입력하십시오: 

새 암호를 다시 입력하십시오: 

이름과 성을 입력하십시오. 

[Unknown]: Yang JeongSoo 

조직 단위 이름을 입력하십시오. 

[Unknown]: Kandroid 

조직 이름을 입력하십시오. 

[Unknown]: Kandroid 

구/군/시 이름을 입력하십시오? 

[Unknown]: Seoul 

시/도 이름을 입력하십시오. 

[Unknown]: Seoul 

이 조직의 두 자리 국가 코드를 입력하십시오. 

[Unknown]: KR 

CN=Yang JeongSoo, OU=Kandroid, O=Kandroid, L=Seoul, ST=Seoul, C=KR이(가) 맞습니까? 

[아니오]: y 

에 대한 키 암호를 입력하십시오. 

(keystore 암호와 같은 경우 Enter를 누르십시오): 

kandroid_store 파일 생성됨 


72


D:\android-sdk-windows-1.1_r1\tools>"c:\Program Files\Java\jdk1.6.0_10\bin\keytool.exe" 

-list -keystore kandroid_keystore 

keystore 암호를 입력하십시오: 

Keystore 유형: JKS 

Keystore 공급자: SUN 

Keystore에는 1 항목이 포함되어 있습니다. 

kandroid_key, 2009. 3. 16, PrivateKeyEntry, 

인증서 지문(MD5): 63:33:67:6F:85:XXXXXXXXXXXXX:14:4F:66:6E 


73

http://code.google.com/android/maps-api-signup.html 


74


D:\android-sdk-windows-1.1_r1\tools>"c:\Program Files\Java\jdk1.6.0_10\bin\jarsigner.exe" 

-verbose -keystore kandroid_keystorekeystore NooYawk.apk apk kandroid_keykey 

Enter Passphrase for keystore: 

adding: META-INF/KANDROID.SF 

adding: META-INF/KANDROID.DSA 

DSA 

signing: res/drawable/icon.png 

signing: res/drawable/marker.png 

signing: res/layout/main.xml 

signing: AndroidManifest.xml 

signing: resources.arsc 

signing: classes.dex 

D:\android-sdk-windows-1.1_r1\tools>adb.exe install NooYawk.apk 

496 KB/s (0 bytes in 15873.000s) 

pkg: /data/local/tmp/NooYawk.apk 

Success 


75



76


 

 

 

 

 

 

 


API Level 3 

API Level 4 

 

 

 

 

 

t .. t 

 

 

.. 

 

 

.. 

 

 

API Level 4 

 

permission> 

 

 

 

 

 


77

The AndroidManifest.xml File manifest 


android:sharedUserId 

The name of a Linux user ID that will be shared with other applications. By default, Android 

assigns each application its own unique user ID. However, if this attribute is set to the same value 

for two or more applications, they will all share the same ID - provided that they are also signed 

by the same certificate. t Application with the same user ID can access each other's data and, if 

desired, run in the same process. 

android:versionCode 

An internal version number. This number is used only to determine whether one version is more 

recent than another, with higher numbers indicating more recent versions. This is not the version 

number shown to users; that number is set by the versionName attribute. 

The value must be set as an integer, such as "100". You can define it however you want, as long 

as each successive version has a higher number. For example, it could be a build number. Or you 

could translate a version number in "x.y" format to an integer by encoding the "x" and "y" 

separately in the lower and upper 16 bits. Or you could simply increase the number by one each 

time a new version is released. 


79




android:process 

Singing by same key 

= 




Activity 

Activity 

Task 

Activity 

Activity 

ContentProvider 


Service 

Service 

APK Package 

Process 

APK Package 

Include 

Dalvik VM 


80


 

 

 

 

 

 

 


API Level 3 

API Level 4 

 

 

 

 

 

t .. t 

 

 

.. 

 

 

.. 

 

 

API Level 4 

 

permission> 

 

 

 

 

 


81

The AndroidManifest.xml File manifest/instrumentation 

 


82


android:functionalTest 

Whether or not the Instrumentation class should run as a functional test ? "true" if it should, 

and "false" if not. The default value is "false". 

android:handleProfiling 

Whether or not the Instrumentation object will turn profiling on and off ? "true" if it 

determines when profiling starts and stops, and "false" if profiling continues the entire time it 

is running. A value of "true" enables the object to target profiling at a specific set of 

operations. The default value is "false". 

android:targetPackage 

The application that the Instrumentation object will run against. An application is identified 

by the package name assigned in its manifest file by the element. 


83


./apps/Music/tests/AndroidManifest.xml 

 

 

 

 

 

 

 

 

 

 

 

 


84

The AndroidManifest.xml File manifest/permission 

 

./apps/IM/AndroidManifest.xml 

 


85

The AndroidManifest.xml File manifest/permission 

Constant V Description 

normal 0 A lower-risk permission that gives an application access to isolated application-level 

features, with minimal i risk to other applications, the system, or the user. The system 

automatically grants this type of permission to a requesting application at installation, with 

out asking for the user's explicit approval (though the user always has the option to review 

these permissions before installing). 

dangerous 1 A higher-risk permission that would give a requesting application access to private user 

data or control over the device that can negatively impact the user. Because this type of 

permission introduces potential risk, the system may not automatically grant it to the 

requesting application. For example, any dangerous permissions requested by an 

application may be displayed to the user and require confirmation before proceeding, or 

some other approach may be taken to avoid the user automatically allowing the use of 

such facilities. 

signature 2 A permission that the system is to grant only if the requesting application is signed with 

the same certificate as the application that declared the permission. If the certificates 

match, the system automatically grants the permission without notifying the user or 

asking for the user's explicit approval. 

Signature 3 A permission that the system is to grant only to packages in the Android system image or 

OrSystem 

that t are signed with the same certificates. t Please avoid using this option, as the signature 

protection level should be sufficient for most needs and works regardless of exactly where 

applications are installed. This permission is used for certain special situations where 

multiple vendors have applications built in to a system image which need to share specific 

features explicitly because they are being built together. 


86

The AndroidManifest.xml File manifest/permission-group 

 


87

The AndroidManifest.xml File manifest/permission-tree 

 

Declares the base name for a tree of permissions. The application takes ownership of all 

names within the tree. It can dynamically add new permissions to the tree by calling 

PackageManager.addPermission(). Names within the tree are separated by periods ('.'). For 

example, if the base name is com.example.project.taxes, permissions like the following might 

be added: 

com.example.project.taxes.CALCULATE 

com.example.project.taxes.deductions.MAKE_SOME_UP 

com.example.project.taxes.deductions.EXAGGERATE 

p Note that this element does not declare a permission itself, only a namespace in which further 

permissions can be placed. See the element for information on declaring 

permissions. 

android:name 

The name that's at the base of the permission tree. It serves as a prefix to all permission 

names in the tree. Java-style scoping should be used to ensure that the name is unique. The 

name must have more than two period-separated p seqments in its path - for example, 

com.example.base is OK, but com.example is not. 


88

The AndroidManifest.xml File : menifest/uses-permission 

 

description: 

Requests a permission that the application must be granted in order for it to operate correctly. 

Permissions i are granted when the application is installed, not while it's running. 

For more information on permissions, see the Permissions section in the introduction and the 

separate Security and Permissions document. A list of permissions defined by the base platform 

can be found at android.Manifest.permission. 

attributes: 

android:name 

The name of the permission. It can be a permission defined by the application with the 

element, a permission defined by another application, or one of the standard 

system permissions, such as "android.permission.CAMERA" or 

"android.permission.READ_CONTACTS". As these examples show, a permission name typically 

includes the package name as a prefix. 


89

The AndroidManifest.xml File : menifest/uses-sdk (old) 

 

description: 

Declares which levels of the Android API the application can run against. The level is incremented 

when there are additions to the API and resource tree, so an application developed using level 3 of 

the API may not run against level 1 or 2, but should run against level 3, 4, 5, and above. 

The default level is 1. 

For more information on the API level, see the Specifying Minimum System API Version section of 

Versioning Your Applications. 

attributes: 

android:minSdkVersion 

An integer designating the minimum level of the Android API that's required for the application to run. 

Despite its name, this attribute is set to the API level, not to the version number of the SDK (software 

development kit). The API level is always a single integer; the SDK version may be split into major 

and minor components (such as 1.2). You cannot derive the API level from the SDK version number 

(for example, it is not the same as the major version or the sum of the major and minor versions). To 

learn what the API level is, check the notes that came with the SDK you're using. 


90

The AndroidManifest.xml File : menifest/uses-sdk (old) 

Android 1.1 Version Notes 

Date: February 2009 

API Level: 2 

 

... 

 

... 

 

• External Libraries : com.google.android.maps 

• Device Compatibility : T-Mobile G1 

• Built-in Applications 

•Alarm Clock / API Demos / Browser / Calculator / Camera / Contacts / Dev Tools 

•Dialer / Email / Maps (and StreetView) / Messaging / Music / Pictures / Settings 

• UI Localizations 

•English, US (en_US) / German (de) 

• Resolved Issues 

• New Features 

• API Changes 


91

The AndroidManifest.xml File : menifest/uses-sdk (new) 

 

description: 

Lets you express an application's compatibility with one or more versions of the Android platform, by 

means of an API Level integer. The API Level expressed by an application will be compared to the 

API Level of a given Android system, which may vary among different Android devices. 

Despite its name, this element is used to specify the API Level, not the version number of the SDK 

(software development kit). The API Level is always a single integer; the SDK version may be split 

into major and minor components (such as 1.5). 

You cannot derive the API Level from the SDK version Platform Version API Level 

number (for example, it is not the same as the major 

Android 2.1 7 

version or the sum of the major and minor versions). 

Android 2.0.1 6 

For more information, read about Android API Levels 

Android 2.0 5 

and Versioning Your Applications. Android 1.6 4 

Android 1.5 3 

Android 1.1 2 

Android 1.0 1 


92

The AndroidManifest.xml File : menifest/uses-sdk (new) 

android:maxSdkVersion 

An integer designating the maximum API Level on which the application is designed to run. The 

Android system will prevent the user from installing the application if the system's API Level is higher 

than the value specified in this attribute. 

Introduced in: API Level 4 

android:targetSdkVersion 

An integer designating the API Level that the application is targetting. 

With this attribute set, the application says that it is able to run on older versions (down to 

minSdkVersion), but was explicitly tested to work with the version specified here. Specifying this 

target version allows the platform to disable compatibility settings that are not required for the target 

version (which may otherwise be turned on in order to maintain forward-compatibility) or enable 

newer features that are not available to older applications. This does not mean that you can program 

different features for different versions of the platform?it simply informs the platform that you have 

tested against the target version and the platform should not perform any extra work to maintain 

forward-compatibility with the target version. 

Introduced in: API Level 4 


93

The AndroidManifest.xml File : menifest/uses-configuration 

 

description: 

Indicates what hardware and software features the application requires. For example, an application 

might specify that it requires a physical keyboard or a particular navigation device, like a trackball. 

The specification is used to avoid installing the application on devices where it will not work. 

If an application can work with different device configurations, it should include separate 

declarations for each one. Each declaration must be complete. For example, if an 

application requires a five-way navigation control, a touch screen that can be operated with a finger, 

and either a standard QWERTY keyboard or a numeric 12-key keypad like those found on most 

phones, it would specify these requirements with two elements as follows: 


94


android:reqFiveWayNav 

Whether or not the application requires a five-way navigation control 

-"true" if it does, and "false" if 

not. A five-way control is one that can move the selection up, down, right, or left, and also provides a 

way of invoking the current selection. It could be a D-pad (directional pad), trackball, or other device. 

If an application requires a directional control, but not a control of a particular type, it can set this 

attribute to "true" and ignore the reqNavigation attribute. However, if it requires a particular type of 

directional control, it can ignore this attribute and set reqNavigation instead. 

android:reqFiveWayNav 

Whether or not the application requires a hardware keyboard - "true" if it does, and "false" if not. 


95


android:reqKeyboardType 

The type of keyboard the application requires, if any at all. This attribute does not distinguish bet 

ween hardware and software keyboards. If a hardware keyboard of a certain type is required, spec 

ify the type here and also set the reqHardKeyboard attribute to "true". 

The value must be one of the following strings: 

Value 

"undefined" 

"nokeys" 

"qwerty" 

"twelvekey" 

Description 

The application does not require a keyboard. (A keyboard requirement is not defined.) 

This is the default value. 

The application does not require a keyboard. 

The application requires a standard QWERTY keyboard. 

The application requires a twelve-key keypad, like those on most phones 

- with keys for the digits from 0 through 9 plus star (*) and pound (#) keys. 


96


android:reqNavigation 

The navigation device required by the application, if any. The value must be one of the following 

strings: 

Value 

"undefined" 

"nonav" 

"dpad" 

"trackball" 

"wheel" 

Description 

The application does not require any type of navigation control. 

(The navigation requirement is not defined.) This is the default value. 

The application does not require a navigation control. 

The application requires a D-pad (directional pad) for navigation. 

The application requires a trackball for navigation. 

The application requires a navigation wheel. 

If an application requires a navigational control, but the exact type of control doesn't matter, it ca 

n set the reqFiveWayNav attribute to "true" rather than set this one. 


97


android:reqTouchScreen 

The type of touch screen the application requires, if any at all. The value must be one of the follo 

wing strings: 

Value 

"undefined" 

"notouch" 

"stylus" 

"finger" 

Description 

The application doesn't require a touch screen. 

(The touch screen requirement is undefined.) This is the default value. 

The application doesn't require a touch screen. 

The application requires a touch screen that's operated with a stylus. 

The application requires a touch screen that can be operated with a finger. 


98

The AndroidManifest.xml File : menifest/uses-feature 

 

description: 

This element declares a specific feature used by the application. Android provides some features that 

may not be equally supported by all Android devices. In a manner similar to the element, 

this element allows an application to specify which device-variable variable features it uses. In this way, the 

application will not be installed on devices that do not offer the feature. 

For example, an application might specify that it requires a camera with auto-focus capabilities. If a 

device does not provide a camera with auto-focus, then it will not allow installation of the application. 

In order to maintain strict device compatibility, it's very important that you use this element to declare 

all features that your application uses. Failure to declare a feature may result your application being 

installed on a device that does not support the feature and your application failing. 

For some features, there may exist a specfic attribute that allows you to define a version of the 

feature, such as the version of Open GL used (declared with glEsVersion). Other features that either 

do or do not exist for a device, such as camera auto-focus, are declared using the name attribute. 

Any software or hardware features that may vary among Android-powered devices will be listed on 

this page among the attributes below. If you see any features here that you use in your application, 

you should include a element for each one. For example, if your application uses the 

device camera, then you should include the following in your AndroidManifest.xml: 


99


 

description: 

 

If you declare "android.hardware.camera", then your application is considered compatible with all 

devices that include a camera, regardless of whether auto-focus is available or not. If you also use 

the auto-focus features (available through the Camera API), then you need to include an additional 

element that declares the "android.hardware.camera.autofocus autofocus" feature. Also note 

that you must still request the CAMERA permission. Requesting permission grants your application 

access to the appropriate hardware and software, while declaring the features used by your 

application ensures proper device compatibility. 

Although the element is only activated for devices running API Level 4 or higher, it is 

safe to include this for applications that declare a minSdkVersion of "3" or lower. Devices running 

older versions of the platform will simply ignore this element, but newer devices will recognize it and 

enforce installation restrictions based on whether the device supports the feature. 

Note: For each feature required by your application, you must include a new element. 

Multiple features cannot be declared in one instance of this element. 


100


android:glEsVersion 

The GLES version needed by the application. The higher 16 bits represent the major number and the 

lower 16 bits represent the minor number. For example, for GL 1.2 referring to 0x00000102, the actual 

value should be set as 0x00010002. 

android:name 

The name of a feature required by the application. The value must be one of the following accepted 

strings: 

Feature Value Description 

Camera "android.hardware.camera" The application requires a camera. 

"android.hardware.camera.autofocus" 

The application requires a camera with auto-focus 

capability. 

As a prerequisite, "android.hardware.camera" must 

also be declared with a separate 

element. 

Note: Any application that requests the CAMERA permission but does not declare any camera 

features with the element will be assumed to use all camera features (such as 

auto-focus). Thus, the application will not be compatible with devices that do not support all 

features. Please use to declare only the camera features that your application 

needs. 


101

The AndroidManifest.xml File : menifest/supports-screen 

 

description: 

Lets you specify the screen dimensions the application supports. By default a modern application 

(using API Level 4 or higher) supports all screen sizes and must explicitly disable certain screen sizes 

here; older applications are assumed to support only the "normal" screen size. Note that screen size 

is a separate axis from density. Screen size is determined as the available pixels to an application 

after density scaling has been applied. 

Based on the target device screen density, the Android framework will scale down assets by a factor 

of 0.75 (low dpi screens) or scale them up by a factor of 1.5 (high dpi screens). The screen density is 

expressed as dots-per-inch (dpi). 

Currently supported densities: 

• Low density: 120 dpi 

• Medium density: 160 dpi 

• High density: 240 dpi 

Table of display types: 

Low Density Medium Density High Density 

Small Screen QVGA n/a VGA 

Normal Screen WQVGA HVGA WVGA, FWVGA 

Large Screen n/a VGA, WVGA, FWVGA n/a 


102

The AndroidManifest.xml File : menifest/supports-screen 

android:smallScreens 

Indicates whether the application supports smaller screen form-factors. A small screen is defined as 

one with a smaller aspect ratio than the "normal" (traditional HVGA) screen. An application that does 

not support small screens will not be available for small screen devices, because there is little the 

platform can do to make such an application work on a smaller screen. Applications using API Level 4 

or higher default this to "true", others are "false". 

android:normalScreens 

Indicates whether an application supports the "normal" screen form-factors. Traditionally this is an 

HVGA medium density screen, but WQVGA low density and WVGA high density are also considered to 

be normal. This attribute is "true" by default, and applications currently should leave it that way. 

android:largeScreens 

Indicates whether the application supports larger screen form-factors. A large screen is defined as a 

screen that is significantly larger than a "normal" phone screen, and thus may require some special 

care on the application's part to make good use of it. An application that does not support large screens 

will be placed as a "postage stamp" on such a screen, so that it retains the dimensions it was originally 

designed for. Applications using API Level 4 or higher default to "true", others are "false". 

android:anyDensity 

Indicates whether the application can accommodate any screen density. Older applications (pre API 

Level 4) are assumed unable to accomodate all densities and this is "false" by default. Applications 

using API Level 4 or higher are assumed able to and this is "true" by default. You can explicitly supply 

your abilities i 

here. 


103


 

 

 

 

 

 

 


API Level 3 

API Level 4 

 

 

 

 

 

t .. t 

 

 

.. 

 

 

.. 

 

 

API Level 4 

 

permission> 

 

 

 

 

 


104

애플리케이션 개요 : Activities, Tasks, and Processes (1강.review) 

An Activity is a “molecule”: a discrete chunk of functionality 

A Task is a collection of Activities 

A “processes” is a standard Linux process 

Activity Activity Activity Activity 

Task 


Service 

Process 

APK Package 


Process 

Service 

Process 

APK Package 


105

애플리케이션 개요 : Activities and Tasks (1강.review) 

Task Info : PackageManager 

Task 

Root Activity 

Activity(Count) 

Top Activity 

Task 

Root Activity 


Top Activity 

Task 

Root Activity 


Top Activity 

← Long Click 

Task 

Root Activity 


Top Activity 


106

애플리케이션 개요 : Activities & Tasks (1강.review) 

Affinities and new tasks 

The FLAG_ACTIVITY_NEW_TASK flag 

As described earlier, a new activity is, by default, launched into the task of the activity 

that called startActivity(). It's pushed onto the same stack as the caller. However, if the 

Intent object passed to startActivity() contains the FLAG_ACTIVITY_NEW_TASK flag, 

the system looks for a different task to house the new activity. Often, as the name of 

the flag implies, it's a new task. However, it doesn't have to be. If there's already an 

existing task with the same affinity as the new activity, the activity is launched into that 

task. If not, it begins a new task. 

The allowTaskReparenting attribute 

If an activity has its allowTaskReparenting attribute set to "true", it can move from the 

task it starts in to the task it has an affinity for when that task comes to the fore. For 

example, suppose that an activity that reports weather conditions in selected cities is 

defined as part of a travel application. It has the same affinity as other activities in the 

same application (the default affinity) and it allows reparenting. One of your activities 

starts the weather reporter, so it initially belongs to the same task as your activity. 

However, when the travel application next comes forward, the weather reporter will be 

reassigned to and displayed with that task. 


107

The AndroidManifest.xml File manifest/application 

Affinities and TaskReparenting 

If activity B has its allowTaskReparenting attribute set to "true“, 

Activity B can move from the task(Task #1) it starts in to the task(Task #2) it has an affinity 

for when that task comes to the foreground 

Task #2 Task #2 

C 

(affinity-Y) 

C 

(affinity-Y) 

B 

(affinity-Y) 

Task #1 

same affinity 

Task #1 

move 

A 

(affinity-X) 

B 

(affinity-Y) 

A 

(affinity-X) 

B 

(affinity-Y) 


109


android:allowClearUserData 

Whether or not users are given the option to remove user data - "true" if they are, and "false" if not. If 

the value is "true", as it is by default, the application manager includes an option that allows users to 

clear the data. 

Settings > Applications > Manage Applications > Browser > Clear Data 


110


android:allowTaskReparenting 

Whether or not activities that the application defines can move from the task that started them to the 

task they have an affinity for when that task is next brought to the front - "true" if they can move, and 

"false" if they must remain with the task where they started. The default value is "false". 

The element has its own allowTaskReparenting attribute that can override the value set here. 

See that attribute for more information. 

android:debuggable 

Whether or not the application can be debugged, even when running on a device in user mode - "true" 

if it can be, and "false" if not. The default value is "false". 

android:description 

User-readable text about the application, longer and more descriptive than the application label. The 

value must be set as a reference to a string resource. Unlike the label, it cannot be a raw string. There 

is no default value. 


111


android:enabled 

Whether or not the Android system can instantiate components of the application - "true" if it can, and 

"false" if not. If the value is "true", each component's enabled attribute determines whether that 

component is enabled or not. If the value is "false", it overrides the component-specific values; all 

components are disabled. 

The default value is "true". 

android:hasCode 

Whether or not the application contains any code - "true" if it does, and "false" if not. When the value is 

"false", the system does not try to load any application code when launching components. The default 

value is "true". 

An application would not have any code of its own only if it's using nothing but built-in component 

classes, such as an activity that uses the AliasActivity class, a rare occurrence. 


112


android:manageSpaceActivity 

The fully qualified name of an Activity subclass that the system can launch to let users manage the 

memory occupied by the application on the device. The activity should also be declared with an 

element. 

Settings > Applications > Manage Applications > 


113


android:persistent 

Whether or not the application should remain running at all times - "true" if it should, and "false" if not. 

The default value is "false". Applications should not normally set this flag; persistence mode is intended 

only for certain system applications. 

android:taskAffinity 

An affinity name that applies to all activities within the application, except for those that set a different 

affinity with their own taskAffinity attributes. See that attribute for more information. 

By default, all activities within an application share the same affinity. The name of that affinity is 

the same as the package name set by the element. 


114


./apps/Music/AndroidManifest.xml: android:allowTaskReparenting="true" 

./apps/Mms/AndroidManifest.xml: android:allowTaskReparenting="true“ 

./apps/IM/samples/PluginDemo/AndroidManifest.xml: android:taskAffinity="android.task.im"> 

./apps/IM/AndroidManifest.xml: android:taskAffinity="android.task.im" 

./apps/Music/AndroidManifest.xml: android:taskAffinity="android.task.music" 

./apps/Music/AndroidManifest.xml: android:taskAffinity="" 

./apps/Music/AndroidManifest.xml: android:taskAffinity="android.task.video" 

./apps/Camera/AndroidManifest.xml: android:taskAffinity="" 

./apps/Camera/AndroidManifest.xml: android:taskAffinity="android.task.camera" 

./apps/Camera/AndroidManifest.xml: android:taskAffinity="android.task.camera" 

./apps/Camera/AndroidManifest.xml: android:taskAffinity="android.task.pictures" 

./apps/AlarmClock/AndroidManifest.xml: android:taskAffinity=":AlarmAlert" 

./apps/Calendar/AndroidManifest.xml: android:taskAffinity="android.task.calendar" 

./apps/Contacts/AndroidManifest.xml: android:taskAffinity="android.task.contacts" 

./apps/Contacts/AndroidManifest.xml: android:taskAffinity="" 

./apps/Mms/AndroidManifest.xml: android:taskAffinity="android.task.mms" 

./apps/Mms/AndroidManifest.xml: android:taskAffinity="" 

./apps/Browser/AndroidManifest.xml: android:taskAffinity="android.task.browser" 

./providers/ImProvider/AndroidManifest.xml: android:taskAffinity="android.task.im" 


115

The AndroidManifest.xml File : application/uses-library 

 

description: 

Specifies a shared library that the application must be linked against. This element tells the 

system to include the library's code in the class loader for the package. 

All of the android packages (such as android.app, android.content, android.view, and 

android.widget) are in the default library that all applications are automatically linked against. 

However, some packages (such as maps and awt are in separate libraries that are not 

automatically linked. Consult the documentation for the packages you're using to determine 

which library contains the package code. 

attributes: 

android:name 

The name of the library. 


116

애플리케이션 개요 : Activities, Tasks, and Processes (1강.review) 

An Activity is a “molecule”: a discrete chunk of functionality 

A Task is a collection of Activities 

A “processes” is a standard Linux process 

Activity Activity Activity Activity 

Task 


Service 

Process 

APK Package 


Process 

Service 

Process 

APK Package 


117

애플리케이션 개요 : Activities and Tasks (1강.review) 

Task Info : PackageManager 

Task 

Root Activity 


Top Activity 

Task 

Root Activity 


Top Activity 

Task 

Root Activity 


Top Activity 

← Long Click 

Task 

Root Activity 


Top Activity 


118


Affinities and new tasks 

The FLAG_ACTIVITY_NEW_TASK flag 

As described earlier, a new activity is, by default, launched into the task of the activity 

that called startActivity(). It's pushed onto the same stack as the caller. However, if the 

Intent object passed to startActivity() contains the FLAG_ACTIVITY_NEW_TASK flag, 

the system looks for a different task to house the new activity. Often, as the name of 

the flag implies, it's a new task. However, it doesn't have to be. If there's already an 

existing task with the same affinity as the new activity, the activity is launched into that 

task. If not, it begins a new task. 

The allowTaskReparenting attribute 

If an activity has its allowTaskReparenting attribute set to "true", it can move from the 

task it starts in to the task it has an affinity for when that task comes to the fore. For 

example, suppose that an activity that reports weather conditions in selected cities is 

defined as part of a travel application. It has the same affinity as other activities in the 

same application (the default affinity) and it allows reparenting. One of your activities 

starts the weather reporter, so it initially belongs to the same task as your activity. 

However, when the travel application next comes forward, the weather reporter will be 

reassigned to and displayed with that task. 


119


Launch modes 

Root Activity 

Top Activity 

Task 

standard 

A B C C 

Task 

singleTop 

A B C C 

If C is singleTop 

singleTask 

singleInstance 

Task 

A B C 

D 

If D is singleTask 

or singleInstance 

Task 

singleTask 

D 

E 

If D is singleTask 

Task 

If D is singleInstance 

singleInstance 

E 


120


Launch modes 

Which task will hold the activity that responds to the intent. For the "standard" and 

"singleTop" modes, it's the task that originated the intent (and called startActivity()) - unless 

the Intent object contains the FLAG_ACTIVITY_NEW_TASK flag. In that case, a different task 

is chosen as described in the previous section, Affinities and new tasks. 

Whether there can be multiple instances of the activity. A "standard" or "singleTop" activity 

can be instantiated many times. They can belong to multiple tasks, and a given task can 

have multiple instances of the same activity. 

Whether the instance can have other activities in its task. A "singleInstance" activity stands 

alone as the only activity in its task. If it starts another activity, that activity will be launched 

into a different task regardless of its launch mode - as if FLAG_ACTIVITY_NEW_TASK was in 

the intent. In all other respects, the "singleInstance" mode is identical to "singleTask". 

Whether a new instance of the class will be launched to handle a new intent. For the default 

"standard" mode, a new instance is created to respond to every new intent. Each instance 

handles just one intent. For the "singleTop" mode, an existing instance of the class is reused 

to handle a new intent if it resides at the top of the activity stack of the target task. If it 

does not reside at the top, it is not re-used. Instead, a new instance is created for the new 

intent and pushed on the stack. 


121


Clearing the stack 

The alwaysRetainTaskState attribute 

If this attribute is set to "true" in the root activity of a task, the default behavior just 

described does not happen. The task retains all activities in its stack even after a long 

period. 

The clearTaskOnLaunch attribute 

If this attribute is set to "true" in the root activity of a task, the stack is cleared down to 

the root activity whenever the user leaves the task and returns to it. In other words, it's 

the polar opposite of alwaysRetainTaskState. The user always returns to the task in its 

initial state, even after a momentary absence. 

The finishOnTaskLaunch attribute 

This attribute is like clearTaskOnLaunch, but it operates on a single activity, not an 

entire task. And it can cause any activity to go away, including the root activity. When 

it's set to "true", the activity remains part of the task only for the current session. If the 

user leaves and then returns to the task, it no longer is present. 


122


Clearing the stack 

Root Activity 

Top Activity 

Task 

standard 

A B C C 

Task 

alwaysRetainTaskState A B C C 

Task 

clearTaskOnLaunch A B C C 

Task 

finishOnTaskLaunch A B C C 


123


Starting tasks 

An activity is set up as the entry point for a task by giving it an intent filter with 

"android.intent.action.MAIN" as the specified action and 

"android.intent.category.LAUNCHER" as the specified category. A filter of this kind causes 

an icon and label for the activity to be displayed in the application launcher, giving users a 

way both to launch the task and to return to it at any time after it has been launched. 

This second ability is important: Users must be able to leave a task and then come back to it 

later. For this reason, the two launch modes that mark activities as always initiating a task, 

"singleTask" and "singleInstance", should be used only when the activity has a MAIN and 

LAUNCHER filter. 

A similar difficulty attends the FLAG_ACTIVITY_NEW_TASK flag. If this flag causes an 

activity to begin a new task and the user presses the HOME key to leave it, there must be 

some way for the user to navigate back to it again. Some entities (such as the notification 

manager) always start activities in an external task, never as part of their own, so they 

always put FLAG_ACTIVITY_NEW_TASK in the intents they pass to startActivity(). If you 

have an activity that can be invoked by an external entity that might use this flag, take care 

that the user has a independent way to get back to the task that's started. 

For those cases where you don't want the user to be able to return to an activity, set the 

element's finishOnTaskLaunch to "true". 


124

The AndroidManifest.xml File : application/activity (old) 

 


125

The AndroidManifest.xml File : application/activity (new) 

The AndroidManifest.xml File : application/activity 

android:allowTaskReparenting 

Whether or not the activity can move from the task that started it to the task it has an affinity for 

when that task is next brought to the front - "true" if it can move, and "false" if it must remain with 

the task where it started. 

If this attribute is not set, the value set by the corresponding allowTaskReparenting attribute of the 

element e e applies to the activity. The default value is "false". 

Normally when an activity is started, it's associated with the task of the activity that started it and it 

stays there for its entire lifetime. You can use this attribute to force it to be re-parented to the task 

it has an affinity for when its current task is no longer displayed. Typically, y, it's used to cause the 

activities of an application to move to the main task associated with that application. 

For example, if an e-mail message contains a link to a web page, clicking the link brings up an 

activity that can display the page. That activity is defined by the browser application, but is 

launched as part of the e-mail task. If it's reparented to the browser task, it will be shown when 

the browser next comes to the front, and will be absent when the e-mail task again comes forward. 

The affinity of an activity is defined by the taskAffinity attribute. The affinity of a task is determined 

by reading the affinity of its root activity. Therefore, by definition, a root activity is always in a task 

with the same affinity. Since activities with "singleTask" or "singleInstance" launch modes can only 

be at the root of a task, re-parenting is limited to the "standard" and "singleTop" modes. (See also 

the launchMode attribute.) 


127


android:alwaysRetainTaskState 

Whether or not the state of the task that the activity is in will always be maintained by the system - 

"true" if it will be, and "false" if the system is allowed to reset the task to its initial state in certain 

situations. The default value is "false". This attribute is meaningful only for the root activity of a 

task; it's ignored for all other activities. 

Normally, the system clears a task (removes es all activities from the stack above the root activity) in 

certain situations when the user re-selects that task from the home screen. Typically, this is done 

if the user hasn't visited the task for a certain amount of time, such as 30 minutes. 

However, when this attribute is "true", users will always return to the task in its last state, 

regardless of how they get there. This is useful, for example, in an application like the web 

browser where there is a lot of state (such as multiple open tabs) that users would not like to lose. 


128


android:clearTaskOnLaunch 

Whether or not all activities will be removed from the task, except for the root activity, whenever it 

is re-launched from the home screen - "true" if the task is always stripped down to its root activity, 

and "false" if not. The default value is "false". This attribute is meaningful only for activities that 

start a new task (the root activity); it's ignored for all other activities in the task. 

When the value is "true", every e time users s start the task again, they are brought to its root activity, 

regardless of what they were last doing in the task and regardless of whether they used BACK or 

HOME to last leave it. When the value is "false", the task may be cleared of activities in some 

situations (see the alwaysRetainTaskState attribute), but not always. 

Suppose, for example, that someone launches activity P from the home screen, and from there 

goes to activity Q. The user next presses HOME, and then returns to activity P. Normally, the user 

would see activity Q, since that is what they were last doing in P's task. However, if P set this flag 

to "true", all of the activities on top of it (Q in this case) were removed when the user pressed 

HOME and the task went to the background. So the user sees only P when returning to the task. 

If this attribute and allowTaskReparenting are both "true", any activities that can be re-parented 

are moved to the task they share an affinity with; the remaining activities are then dropped, as 

described above. 


129


android:configChanges 

Lists configuration changes that the activity will handle itself. When changes that are not listed 

occur, the activity is shut down and restarted. When a listed change occurs, the activity remains 

running and its onConfigurationChanged() method is called. 

Any or all of the following strings can be used to set this attribute. Values are separated by '|‘ - for 

example, pe, "locale|navigation|orientation". 

a o |o e a o 

Value 

"mcc" 

"mnc" 

"locale" 

Description 

The IMSI mobile country code (MCC) has changed - that is, a SIM has been detected and updated the MCC. 

The IMSI mobile network code (MNC) has changed - that is, a SIM has been detected and updated the MNC. 

The locale has changed - for example, the user has selected a new language that text should be displayed in. 

"touchscreen" The touchscreen has changed. (This should never normally happen.) 

"keyboard" 

The keyboard type has changed - for example, the user has plugged in an external keyboard. 

"keyboardHidden" The keyboard accessibility has changed - for example, the user has slid the keyboard out to expose it. 

"navigation" 

The navigation type has changed. (This should never normally happen.) 

"orientation" 

The screen orientation has changed - that is, the user has rotated the device. 

"fontScale" 

The font scaling factor has changed - that is, the user has selected a new global font size. 

All of these configuration changes can impact the resource values seen by the application. 

Therefore, when onConfigurationChanged() is called, it will generally be necessary to again 

retrieve all resources (including view layouts, drawables, and so on) to correctly handle the 

change. 


130


android:enabled 

Whether or not the activity can be instantiated by the system -"true" if it can be, and "false" if not. 

The default value is "true". 

The element has its own enabled attribute that applies to all application 

components, including activities. The and attributes must both be "true" 

(as they both are by default) for the system to be able to instantiate a the activity. If either e is "false", 

it cannot be instantiated. 

android:excludeFromRecents 

Whether or not the activity should be excluded from the list of recently launched activities that can 

be displayed to users - "true" if it should be excluded, and "false" if it should be included. The 

default value is "false". 


131


android:exported 

Whether or not the activity can be launched by components of other applications - "true" if it can 

be, and "false" if not. If "false", the activity can be launched only by components of the same 

application or applications with the same user ID. 

The default value depends on whether the activity contains intent filters. The absence of any 

filters means that the activity can be invoked only by specifying its exact class name. This implies 

that the activity is intended only for application-internal use (since others would not know the 

class name). So in this case, the default value is "false". On the other hand, the presence of at 

least one filter implies that the activity is intended for external use, so the default value is "true". 

This attribute is not the only way to limit an activity's exposure to other applications. You can also 

use a permission to limit the external entities that can invoke the activity (see the permission 

attribute). 

android:finishOnTaskLaunch 

Whether or not an existing instance of the activity should be shut down (finished) whenever the 

user again launches its task (chooses the task on the home screen) - "true" if it should be shut 

down, and "false" if not. The default value is "false". 

If this attribute and allowTaskReparenting are both "true", this attribute trumps the other. The 

affinity of the activity is ignored. The activity is not re-parented, but destroyed. 


132


android:launchMode 

An instruction on how the activity should be launched. There are four modes that work in 

conjunction with activity flags (FLAG_ACTIVITY_* constants) in Intent objects to determine what 

should happen when the activity is called upon to handle an intent. They are: 

"standard" 

"singleTop" 

ge "singleTask" 

"singleInstance" 

The default mode is "standard". 

The modes fall into two main groups, with "standard" and "singleTop" activities on one side, and 

"singleTask" and "singleInstance" activities on the other. An activity with the "standard" or 

"singleTop" launch mode can be instantiated multiple times. The instances can belong to any task 

and can be located anywhere in the activity stack. Typically, they're launched into the task that 

called startActivity() (unless the Intent object contains a FLAG_ACTIVITY_NEW_TASK instruction, 

in which case a different task is chosen ? see the taskAffinity attribute). 

In contrast, "singleTask" and "singleInstance" activities can only begin a task. They are always at 

the root of the activity stack. Moreover, the device can hold only one instance of the activity at a 

time - only one such task. 


133


The "standard" and "singleTop" modes differ from each other in just one respect: Every time 

there's new intent for a "standard" activity, a new instance of the class is created to respond to 

that intent. Each instance handles a single intent. Similarly, a new instance of a "singleTop" 

activity may also be created to handle a new intent. However, if the target task already has an 

existing instance of the activity at the top of its stack, that instance will receive the new intent (in 

an onNewIntent() e call); a new instance is not created. ed In other circumstances cu ces ? for example, e, if an 

existing instance of the "singleTop" activity is in the target task, but not at the top of the stack, or if 

it's at the top of a stack, but not in the target task ? a new instance would be created and pushed 

on the stack. 

The "singleTask" and "singleInstance" modes also differ from each other in only one respect: A 

"singleTask" activity allows other activities to be part of its task. It's at the root of the activity stack, 

but other activities (necessarily "standard" and "singleTop" activities) can be launched into the 

same task. A "singleInstance" activity, on the other hand, permits no other activities to be part of 

its task. It's the only activity in the task. If it starts another activity, that activity is assigned to a 

different task - as if FLAG_ACTIVITY_NEW_TASK was in the intent. 

For more information on launch modes and their interaction with Intent flags, see the Activities 

and Tasks section of the Application Fundamentals document. 


134


android:multiprocess 

Whether an instance of the activity can be launched into the process of the component that 

started it -"true" if it can be, and "false" if not. The default value is "false". 

Normally, a new instance of an activity is launched into the process of the application that defined 

it, so all instances of the activity run in the same process. However, if this flag is set to "true", 

instances of the activity can run in multiple processes, allowing the system to create instances 

wherever e e they are used (provided permissions s allow it), something that is almost never e necessary 

or desirable. 

android:name 

The name of the class that implements the activity, a subclass of Activity. The attribute value 

should be a fully qualified class name (such as, "com.example.project.ExtracurricularActivity"). 

However, as a shorthand, if the first character of the name is a period (for example, 

".ExtracurricularActivity"), it is appended to the package name specified in the 

element. 

There is no default. The name must be specified. 

android:permission 

The name of a permission that clients must have to launch the activity or otherwise get it to 

respond to an intent. If a caller of startActivity() or startActivityForResult() has not been granted 

the specified permission, its intent will not be delivered to the activity. 

If this attribute is not set, the permission set by the element's permission attribute 

applies to the activity. If neither attribute is set, the activity is not protected by a permission. 


135



The name of the process in which the activity should run. Normally, all components of an 

application run in the default process created for the application. It has the same name as the 

application package. The element's process attribute can set a different default for 

all components. But each component can override the default, allowing you to spread your 

application across multiple processes. 

If the name assigned to this attribute begins with a colon (':'), a new process, private to the 

application, is created when it's needed and the activity runs in that process. If the process name 

begins with a lowercase character, the activity will run in a global process of that name, provided 

that it has permission to do so. This allows components in different applications to share a 

process, reducing resource usage. 


136


android:screenOrientation 

The orientation of the activity's display on the device. The value can be any one of the following 

strings: 

"unspecified" 

"landscape" 

"portrait" 

"user" 

"behind" 

"sensor" 

"nosensor" 

The default value. The system chooses the orientation. The policy it uses, and therefore 

the choices made in specific contexts, may differ from device to device. 

Landscape orientation (the display is wider than it is tall). 

Portrait orientation (the display is taller than it is wide). 

The user's current preferred orientation. 

The same orientation as the activity that's immediately beneath it in the activity stack. 

The orientation determined by a physical orientation sensor. The orientation of the display 

depends on how the user is holding the device; it changes when the user rotates the 

device. 

An orientation determined without reference to a physical orientation sensor. The sensor 

is ignored, so the display will not rotate based on how the user moves the device. Except 

for this distinction, the system chooses the orientation using the same policy as for the 

"unspecified" setting. 


137


android:stateNotNeeded 

Whether or not the activity can be killed and successfully restarted without having saved its state - 

"true" if it can be restarted without reference to its previous state, and "false" if its previous state is 

required. The default value is "false". 

Normally, before an activity is temporarily shut down to save resources, its onSaveInstanceState() 

method is called. This method stores the current state of the activity in a Bundle object, which is 

then passed to onCreate() when the activity is restarted. If this attribute is set to "true", 

onSaveInstanceState() may not be called and onCreate() will be passed null instead of the 

Bundle - just as it was when the activity started for the first time. 

A "true" setting ensures that the activity can be restarted in the absence of retained state. For 

example, the activity that displays the home screen uses this setting to make sure that it does not 

get removed if it crashes for some reason. 


138


android:taskAffinity 

The task that the activity has an affinity for. Activities with the same affinity conceptually belong to the 

same task (to the same "application" from the user's perspective). The affinity of a task is determined 

by the affinity of its root activity. 

The affinity determines two things - the task that the activity is re-parented to (see the 

allowTaskReparenting attribute) and the task that will house the activity when it is launched with the 

FLAG_ACTIVITY_NEW_TASK flag. 

By default, all activities in an application have the same affinity. You can set this attribute to group them 

differently, and even place activities defined in different applications within the same task. To specify 

that the activity does not have an affinity for any task, set it to an empty string. 

If this attribute is not set, the activity inherits the affinity set for the application (see the 

element's taskAffinity attribute). The name of the default affinity for an application is the package name 

set by the element. 

android:theme 

A reference to a style resource defining an overall theme for the activity. This automatically sets the 

activity's context to use this theme (see setTheme(), and may also cause "starting" animations prior to 

the activity being launched (to better match what the activity actually looks like). 

If this attribute is not set, the activity inherits the theme set for the application as a whole ? see the 

i element's theme attribute. If that attribute is also not set, the default system theme is 

used. 


139


android:windowSoftInputMode 

How the main window of the activity interacts with the window containing the on-screen soft keyboard. 

The setting for this attribute affects two things: 

• The state of the soft keyboard - whether it is hidden or visible - when the activity becomes the focus of 

user attention. 

• The adjustment made to the activity's main window - whether it is resized smaller to make room for 

the soft keyboard or whether its contents pan to make the current focus visible when part of the window 

is covered by the soft keyboard. 

The setting must be one of the values listed in the following table, or a combination of one "state..." 

value plus one "adjust..." value. Setting multiple values in either group - multiple "state..." values, for 

example &mdash has undefined results. Individual values are separated by a vertical bar (|). For 

example: 

 

Values set here (other than "stateUnspecified" and "adjustUnspecified") override values set in the 

theme. 

중략.. 


140

The AndroidManifest.xml File : application/activity-alias 

 

android:name="string" 

android:permission="string" 

android:targetActivity="string" > 


141

The AndroidManifest.xml File : application/activity-alias 

android:name 

A unique name for the alias. The name should resemble a fully qualified class name. But, unlike the 

name of the target activity, the alias name is arbitrary; it does not refer to an actual class. 

android:targetActivity 

The name of the activity that can be activated through the alias. This name must match the name 

attribute of an element that precedes the alias in the manifest. 


142

The AndroidManifest.xml File : application/receiver 

The AndroidManifest.xml File : application/service 

The AndroidManifest.xml File : component(a,s,r)/intent-filter 

 

. . . 

 

android:priority 

d o The priority that should be given to the parent component with regard to handling intents of the type 

described by the filter. This attribute has meaning for both activities and broadcast receivers: 

• It provides information about how able an activity is to respond to an intent that matches the filter, 

relative to other activities that could also respond to the intent. When an intent could be handled by 

multiple activities with different priorities, Android will consider only those with higher priority values 

as potential targets for the intent. 

• It controls the order in which broadcast receivers are executed to receive broadcast messages. 

Those with higher priority values are called before those with lower values. (The order applies only to 

synchronous messages; it's ignored for asynchronous messages.) 

Use this attribute only if you really need to impose a specific order in which the broadcasts are 

received, or want to force Android to prefer one activity over others. 

The value must be an integer, such as "100". Higher numbers have a higher priority. 


145

The AndroidManifest.xml File : intent-filter/action 

 

android:name 

The name of the action. Some standard actions are defined in the Intent class as ACTION_string 

constants. t To assign one of these actions to this attribute, t prepend "android.intent.action." i t ti "to the 

string that follows ACTION_. For example, for ACTION_MAIN, use "android.intent.action.MAIN" 

and for ACTION_WEB_SEARCH, use "android.intent.action.WEB_SEARCH". 

For actions you define, it's best to use the package name as a prefix to ensure uniqueness. For 

example, a TRANSMOGRIFY action might be specified as follows: 

 


146

The AndroidManifest.xml File : intent-filter/category 

 

android:name 

The name of the category. Standard categories are defined in the Intent class as 

CATEGORY_name constants. t The name assigned here can be derived d from those constants t by 

prefixing "android.intent.category." to the name that follows CATEGORY_. 

For example, the string value for CATEGORY_LAUNCHER is 

"android.intent.category.LAUNCHER". 

i t t Custom categories should use the package name as a prefix, to ensure that they are unique. 


147

The AndroidManifest.xml File : intent-filter/data 

 

다음장에서 상세 설명 


148


android:host 

The host part of a URI authority. This attribute is meaningless unless a scheme attribute is also 

specified for the filter. 

android:path 

android:pathPrefix 

android:pathPattern 

The path part of a URI. The path attribute specifies a complete path that is matched against the 

complete path in an Intent object. The pathPrefix attribute specifies a partial path that is matched 

against only the initial part of the path in the Intent object. The pathPattern attribute specifies a 

complete path that is matched against the complete path in the Intent object, but it can contain the 

following wildcards: 

An asterisk ('*') matches a sequence of 0 to many occurrences of the immediately preceding character. 

A period followed by an asterisk (".*") matches any sequence of 0 to many characters. 

Because '\' is used as an escape character when the string is read from XML (before it is parsed as a 

pattern), you will need to double-escape: For example, a literal '*' would be written as "\\*" and a literal 

'\' would be written as "\\\\" . This is basically the same as what you would need to write if constructing 

the string in Java code. 

For more information on these three types of patterns, see the descriptions of PATTERN_LITERAL, 

PATTERN_PREFIX, PREFIX and PATTERN_SIMPLE_GLOB in the PatternMatcher class. 


149


android:mimeType 

A MIME media type, such as image/jpeg or audio/mpeg4-generic. generic The subtype can be the asterisk 

wildcard (*) to indicate that any subtype matches. 

These attributes are meaningful only if the scheme and host attributes are also specified for the filter. 

android:port 

The port part of a URI authority. This attribute is meaningful only if the scheme and host attributes are 

also specified for the filter. 

android:scheme 

The scheme part of a URI. This is the minimal essential attribute for specifying a URI; at least one 

scheme attribute must be set for the filter, or none of the other URI attributes are meaningful. 

A scheme is specified without the trailing colon (for example, http, rather than http:). 

If the filter has a data type set (the mimeType attribute) but no scheme, the content: and file: schemes 

are assumed. 


150

The AndroidManifest.xml File : application/provider 

 

. . . 

 


151


android:authorities 

A list of one or more URI authorities that identify data under the purview of the content provider. 

Multiple authorities are listed by separating their names with a semicolon. To avoid conflicts, authority 

names should use a Java-style naming convention (such as com.example.provider.cartoonprovider). 

Typically, it's the name of the ContentProvider subclass. 

There is no default. At least one authority must be specified. 

android:grantUriPermissions 

Whether or not those who ordinarily would not have permission to access the content provider's data can be granted 

permission i to do so, temporarily overcoming the restriction ti imposed by the readPermission, i writePermission, i i and 

permission attributes ? "true" if permission can be granted, and "{@ code false}" if not. If "true", permission can be 

granted to any of the content provider's data. If "false", permission can be granted only to the data subsets listed in 

subelements, if any. The default value is "false". 

Granting permission is a way of giving an application component one-time access to data protected by a permission. For 

example, when an e-mail message contains an attachment, the mail application may call upon the appropriate viewer to 

open it, even though the viewer doesn't have general permission to look at all the content provider's data. 

In such cases, permission is granted by FLAG_GRANT_READ_URI_PERMISSION and 

FLAG_GRANT_WRITE_URI_PERMISSION GRANT flags in the Intent object that activates the component. For example, the 

mail application might put FLAG_GRANT_READ_URI_PERMISSION in the Intent passed to Context.startActivity(). The 

permission is specific to the URI in the Intent. 

If you enable this feature, either by setting this attribute to "true" or by defining subelements, you 

must call Context.revokeUriPermission() when a covered URI is deleted from the provider. 


152


android:initOrder 

The order in which the content provider should be instantiated, relative to other content providers 

hosted by the same process. When there are dependencies among content providers, setting this 

attribute for each of them ensures that they are created in the order required by those dependencies. 

The value is a simple integer, with higher numbers being initialized first. 

android:readPermission 

A permission that clients must have to query the content provider. See also the permission and 

writePermission attributes. 

android:syncable 

Whether or not the data under the content provider's control is to be synchronized with data on a 

server ? "true" if it is to be synchronized, and "{@ code false}" if not. 

android:writePermission 

A permission that clients must have to make changes to the data controlled by the content provider. 

See also the permission and readPermission attributes. 


153

The AndroidManifest.xml File : provider/grant-uri-permisson 

 

description: 

Specifies which data subsets of the parent content provider permission can be granted for. Data 

subsets are indicated by the path part of a content: URI. (The authority part of the URI identifies 

the content provider.) Granting permission is a way of enabling clients of the provider that don't 

normally have permission to access its data to overcome that restriction on a one-time basis. 

If a content provider's grantUriPermissions attribute is "true", permission can be granted 

for any the data under the provider's purview. However, if that attribute is "false", 

permission can be granted only to data subsets that are specified by this element. A 

provider can contain any number of elements. Each one can specify only 

one path (only one of the three possible attributes). 

For information on how permission is granted, see the element's 

grantUriPermissions attribute. 


154

The AndroidManifest.xml File : provider/path-permisson 

The AndroidManifest.xml File : component/meta-data 

 


156

The AndroidManifest.xml File : component(all)/meta-data 

android:resource 

A reference to a resource. The ID of the resource is the value assigned to the item. The ID can be 

retrieved from the meta-data Bundle by the Bundle.getInt() method. 

android:value 

The value assigned to the item. The data types that can be assigned as values and the Bundle 

methods that components use to retrieve those values are listed in the following table: 

Type 

String value, using double backslashes (\\) to escape characters ? such as "\\n" and 

"\\uxxxxx" for a Unicode character. 

Integer value, such as "100" 

Boolean value, either "true" or "false" 

Color value, in the form "#rgb", "#argb", "#rrggbb", or "#aarrggbb" 

Float value, such as "1.23" 

Bundle method 

getString() 

getInt() 

getBoolean() 

getString() 

getFloat() 


157


Location and Google Map API 실습 


Google MapView API Demo Key 


res/layout/ 

Google Map API 사용법 (using debug keystore) 

1. Import MyMap Project into Eclipse Workplace 

2. Check debug keystore 

Eclipse > Window > Preferences > Android > Build 

ex) Default debug keystore 

C:\Documents and Settings\kandroid\.android\debug.keystore 

3. Get MD5 FingerPrint 

keytool -list -alias androiddebugkey -keystore " C:\Documents and 

Settings\kandroid\.android\debug.keystore " -storepass android -keypass android 

ex ) MD5지문 - E3:A8:7C:67:A3:E6:A7:39:B5:19:F3:2C:F6:A5:30:D3 

4. Get Google Map API Key 


5. Use Google Map API Key, Build with debug keystore, Install, and Start .apk 


160

Google Map API 사용법 (using custom keystore) 

1. On Eclipse Project, Right-click 

2. Create Custom keystore and Build .apk with your custom keystore 

Android Tools > Export Signed Application Package > …. > 

Result 1 : Your custom keystore location and keystore Info. 

Result 2 : Signed apk using custom keystore : c:\MyMap.apk 

M 3. Get MD5 FingerPrint from your custom keystore 

keytool -list -alias androiddebugkey -keystore "C\D C:\Documents and 

Settings\kandroid\.android\debug.keystore " -storepass android -keypass android 

ex ) MD5지문 - E3:A8:7C:67:A3:E6:A7:39:B5:19:F3:2C:F6:A5:30:D3 

4. Get Google Map API Key 


5. Use Google Map API Key, Build with custom keystore, Install, and Start .apk 

cf : adb.exe uninstall 

adb.exe install 


161

Location 

Overview 

The Android SDK includes two packages that provide Android's primary support for building 

location-based services: android.location and com.google.android.maps. Please read on below 

for a brief introduction to each package. 


162

Location 

android.location 

This package contains several classes related to location services in the Android platform. Most 

importantly, it introduces the LocationManager service, which provides an API to determine location and 

bearing if the underlying device (if it supports the service). The LocationManager should not be 

instantiated ti t directly; rather, a handle to it should be retrieved via 

getSystemService(Context.LOCATION_SERVICE). 

Once your application has a handle to the LocationManager, your application will be able to do three 

things: 

• Query for the list of all LocationProviders known to the LocationManager for its last known location. 

• Register/unregister for periodic updates of current location from a LocationProvider (specified either by 

Criteria or name). 

• Register/unregister for a given Intent to be fired if the device comes within a given proximity (specified 

by radius in meters) of a given lat/long. 

However, during initial development, you may not have access to real data from a real location provider 

(Network or GPS). So it may be necessary to spoof some data for your application, with some mock 

location data. 


163

Location 

Providing Mock Location Data 

When testing your application on the Android emulator, there are a couple different ways to send it some 

spoof location data: with the DDMS tool or the "geo" command. 

Using DDMS 

With the DDMS tool, you can simulate location data a few different ways: 

• Manually send individual id longitude/latitude tit d coordinates to the device. 

• Use a GPX file describing a route for playback to the device. 

• Use a KML file describing individual placemarks for sequenced playback to the device. 

For more information on using DDMS to spoof location data, see the Using DDMS guide. 


164

Location 

Providing Mock Location Data 

Using the "geo" command 

Launch your application in the Android emulator and open a terminal/console in your SDK's /tools 

directory. Now you can use: 

> telnet localhost 5554 

• geo fix to send a fixed geo-location. 

This command accepts a longitude and latitude in decimal degrees, and an optional altitude in 

meters. 

For example: 

geo fix -121.45356 46.51119 4392 

geo nmea to send an NMEA 0183 sentence. 

This command accepts a single NMEA sentence of type '$GPGGA' (fix data) or '$GPRMC' (transit 

data). 

For example: 

geo nmea $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62 


165

Location (1.1 까지만 유효..) 

com.google.android.maps 

This package introduces a number of classes related to rendering, controlling, and overlaying 

customized information on your own Google Mapified Activity. The most important of which is the 

MapView class, which automagically draws you a basic Google Map when you add a MapView to your 

layout. Note that, t if you want to do so, then your Activity it that t handles the MapView must extend 

MapActivity. 

Also note that you must obtain a MapView API Key from the Google Maps service, before your MapView 

can load maps data. For more information, see Obtaining i a MapView API Key. 

Once you've created a MapView, you'll probably want to use getController() to retrieve a MapController, 

for controlling and animating the map, and ItemizedOverlay to draw Overlays and other information on 

the Map. 

This is not a standard package in the Android library. In order to use it, you must add the following node 

to your Android Manifest file, as a child of the element: 

 


166

Location (1.5 Special Feature) 

Google Maps External Library 

make it easier for you to add powerful mapping capabilities to your application, Google provides a Maps external library 

that includes the com.google.android.maps package. The classes of the com.google.android.maps package offer built-in 

downloading, rendering, and caching of Maps tiles, as well as a variety of display options and controls. 

The key class in the Maps package is com.google.android.maps.MapView, g p a subclass of ViewGroup. A MapView displays 

a map with data obtained from the Google Maps service. When the MapView has focus, it will capture keypresses and 

touch gestures to pan and zoom the map automatically, including handling network requests for additional maps tiles. It 

also provides all of the UI elements necessary for users to control the map. Your application can also use MapView class 

methods to control the MapView programmatically and draw a number of Overlay types on top of the map. 

In general, the MapView class provides a wrapper around the Google Maps API that lets your application manipulate 

Google Maps data through class methods, and it lets you work with Maps data as you would other types of Views. 

The Maps external library is not part of the standard Android library, so it may not be present on some compliant Androidpowered 

devices. Similarly, the Maps external library is not included in the standard Android library provided in the SDK. 

So that you can develop using the classes of the com.google.android.maps package, the Maps external library is made 

available to you as part of the Google APIs add-on for the Android SDK. 

To learn more about the Maps external library and how to download and use the Google APIs add-on, visit 

http://code.google.com/android/add-ons/google-apis 

For your convenience, the Google APIs add-on is also included in the Android SDK. 

Note: In order to display Google Maps data in a MapView, you must register with the Google Maps service and obtain a 

Maps API Key. For information about how to get a Maps API Key, see Obtaining a Maps API Key. 


167

안드로이드 개발 프로세스(Android 1.5 이후 Feature 1강. Review) 

안드로이드 애플리케이션 빌드 프로세스(1) 

Eclipse 

(ADT Plug-in) 

Java 

compiler 

dx / aapt 

converter 

결과물: 

Unsigned APK 

Java 

Dalvik 

(classes) 

(.dex) 

Ref. Libs 

Unsigned 

Android 

Application 

(.apk) 

∥ 

Resources 

Manifest 

XML Res. 

Compilation 

+ 

Other Res. 

Pre-process 

Zip 

Compressed 

File 

Key 

(Debug Key 

Custom Key) 


168

안드로이드 개발 프로세스(Android 1.5 이후 Feature 1강. Review) 

안드로이드 애플리케이션 빌드 프로세스(2) 

jarsigner 

(keytool) 

zipalign 

adb 

install 

am 

start 

결과물: 

App. Launch 

Android 

Application 

(.apk) 

∥ 

Zip 

Compressed 

File 

Key 

(Debug Key 

Custom Key) 

Signed 

Android 

Application 

(.apk) 

by 

Debug Key 

Signed 

Android 

Application 

(.apk) 

by 

Custom Key 

Aligned 

Android 

Application 

(.apk) 


169

Application Signing : 애플리케이션 빌드,설치,런치 프로세스(1) 

1 

2 

Application Signing based on Debug KeyStore (eclipse/window/preferences/Android/Build/Default debug keystore) 

jarsigner.exe -verbose -keystore “debug.keystore" MyMap.apk androiddebugkey 

Uninstall & Install Package 

D:\android-sdk-windows-1.5_r3\tools>adb.exe uninstall org.kandroid.example.mymap 

D:\android-sdk-windows-1.5_r3\tools>adb.exe install MyMap.apk 

3 

Launch hA Activity 

it 

1. D:\android-sdk-windows-1.5_r3\tools>adb.exe shell am start -D -n org.kandroid.example.mymap/.MyMap 

Starting: Intent { comp={org.kandroid.example.mymap/org.kandroid.example.mymap.MyMap} } 

2. am start –n org.kandroid.example.mymap/.MyMap 

Starting: Intent { comp={org.kandroid.example.mymap/org.kandroid.example.mymap.MyMap} p p g p y p y p}} } 

1 2 

3 

unsigned 

Android 

Application 

(.apk) 

signed 

Android 

Application 

2 

(.apk) 

=> adb.exe 

adbd 

zipaligned 


170

Application Signing : 애플리케이션 빌드,설치,런치 프로세스(2) 

Application Signing based on Custom KeyStore 

jarsigner.exe -verbose -keystore “debug.keystore" MyMap.apk androiddebugkey 

1 

unsigned 

Android 

Application 

(.apk) 

signed 

Android 

Application 

(.apk) 

adb.exe 

adbd 

1 


171

질의및응답 

Q & A 


172

The AndroidManifest.xml File - ìëë¡ì´ë ê¸°ì ì»¤ë®¤ëí° : Korea ...

Create successful ePaper yourself

Delete template?

Save as template?

The AndroidManifest.xml File - ìëë¡ì´ë ê¸°ì ì»¤ë®¤ëí° : Korea ...