3D with OpenGL - 안드로이드 기술 커뮤니티 : Korea Android

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

Graphics, 2D and 3D with OpenGL 

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

public class MyView extends Activity { 

@Override 

public void onCreate(Bundle savedInstanceState) { 

super.onCreate(savedInstanceState); 

setContentView(R.layout.main); 

} 

} 

public class CustomView extends View { 

} 

public CustomView(Context context, AttributeSet attrs, int defStyle) { 

super(context, attrs, defStyle); 

} 

public CustomView(Context context, AttributeSet attrs) { 

super(context, attrs); 

} 

public CustomView(Context context) { 

super(context); 

} 

Korea Android Community- www.kandroid.org 

3


4

@Override 

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { 

setMeasuredDimension(measureWidth(widthMeasureSpec), 

measureHeight(heightMeasureSpec)); 

} 

private int measureHeight(int measureSpec) { 

int result = 0; 

int specMode = MeasureSpec MeasureSpec.getMode(measureSpec); 

getMode(measureSpec); 

int specSize = MeasureSpec.getSize(measureSpec); 

mAscent = (int) mTextPaint.ascent(); 

if (specMode == MeasureSpec.EXACTLY) { 

result = specSize; 

} else { 

result = (int) (-mAscent + mTextPaint.descent()) + getPaddingTop() + getPaddingBottom(); 

if (specMode == MeasureSpec.AT_MOST) { 

result = Math Math.min(result, min(result specSize); 

} 

} 

return result; 

} 

@Override 

protected void onDraw(Canvas canvas) { 

super.onDraw(canvas); 

canvas canvas.drawText(mText, drawText(mText getPaddingLeft() getPaddingLeft(), getPaddingTop() - mAscent mAscent, mTextPaint); 

} 


5


6

 

 

 

< 

t t lO l "f l "/> 

 

 

"false"> 

 

 

 

 

 

 

 

 

 

 

 


7


External Library 사용 

8


9

1. Graphics 

2. 2D Graphics p 

3. 3D with OpenGL

Graphics 

Overview 

Android graphics are powered by a custom 2D graphics library and OpenGL ES 1.0 for high 

performance 3D graphics. The most common 2D graphics APIs can be found in the drawable 

package. OpenGL APIs are available from the Khronos OpenGL ES package, plus some Android 

OOpenGL GL utilities. tiliti 

When starting a project, it's important to consider exactly what your graphical demands will be. 

Varying graphical tasks are best accomplished with varying techniques. For example, graphics 

and d animations i ti ffor a rather th static t ti application li ti should h ld bbe iimplemented l t d much h diff differently tl th than 

graphics and animations for an interactive game or 3D rendering. 

Here, we'll discuss a few of the options you have for drawing graphics on Android, and which 

tasks the they're 're best ssuited ited for for. 

If you're specifically looking for information on drawing 3D graphics, this page won't help a lot. 

However, the information below, on Drawing with a Canvas (and the section on SurfaceView), 

will give you a quick idea of how you should draw to the View hierarchy hierarchy. For more information on 

Android's 3D graphic utilities (provided by the OpenGL ES API), read 3D with OpenGL and refer 

to other OpenGL documentation. 


11

Graphics 

Consider your options 

When drawing 2D graphics, you'll typically do so in one of two ways: 

a. Draw your graphics or animations into a View object from your layout. In this manner, the 

drawing (and any animation) of your graphics is handled by the system's normal View hierarchy 

drawing process - you simply define the graphics to go inside the View. 

b. Draw your graphics directly to a Canvas. This way, you personally call the appropriate class's 

draw() method (passing it your Canvas), or one of the Canvas draw...() methods (like 

drawPicture()). In doing so, you are also in control of any animation. 

Option "a," drawing to a View, is your best choice when you want to draw simple graphics that do 

not need to change dynamically and are not part of a performance-intensive game. For example, 

you should draw your graphics into a View when you want to display a static graphic or predefined 

animation, within an otherwise static application. Read Simple Graphics Inside a View. 

Option "b," drawing to a Canvas, is better when you're application needs to regularly re-draw itself. 

Basically, any video game should be drawing to the Canvas on its own. However, there's more than 

one way to do this: 

• In the same thread as your UI Activity, wherein you create a custom View component in your layout, 

call invalidate() and then handle the onDraw() callback.. 

• Or, in a separate thread, wherein you manage a SurfaceView and perform draws to the Canvas as 

fast as your thread is capable (you do not need to request invalidate()). 


12

Graphics 

Simple Graphics Inside a View 

If you'll be drawing some simple graphics (images, shapes, colors, pre-defined animations, etc.), 

then you should probably just draw to the background of a View or to the content of an ImageView in 

your layout. 

In this case, you can skip the rest of this document and learn how to draw graphics and animations in 

the 2D Graphics document. 


13

Graphics 

Draw with a Canvas 

When you're writing an application in which you would like to perform specialized drawing and/or 

control the animation of graphics, you should do so by drawing through a Canvas. 

A Canvas works for you as a pretense, or interface, to the actual surface upon which your 

graphics will be drawn - it holds all of your "draw" calls. Via the Canvas, your drawing is actually 

performed upon an underlying Bitmap, which is placed into the window. 

In the event that you're drawing within the onDraw() callback method, the Canvas is provided for you 

and you need only place your drawing calls upon it. You can also acquire a Canvas from 

SurfaceHolder.lockCanvas(), when dealing with a SurfaceView object. (Both of these scenarios are 

discussed in the following sections.) 

However, if you need to create a new Canvas, then you must define the Bitmap upon which drawing 

will actually be performed. The Bitmap is always required for a Canvas. You can set up a new Canvas 

like this: 

Bitmap b = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888); 

Canvas c = new Canvas(b); 


14

Graphics 

Draw with a Canvas 

Now your Canvas will draw onto the defined Bitmap. After drawing upon it with the Canvas, you can 

then carry your Bitmap to another Canvas with one of the Canvas.drawBitmap(Bitmap,...) methods. 

It's recommended that you ultimately draw your final graphics through a Canvas offered to you by 

View.onDraw() or SurfaceHolder.lockCanvas() (see the following sections). 

The Canvas class has its own set of drawing methods that you can use, like drawBitmap(...), 

drawRect(...), drawText(...), and many more. Other classes that you might use also have draw() 

methods. For example, you'll probably have some Drawable objects that you want to put on the 

Canvas. Drawable has its own draw() method that takes your Canvas as an arguement. 


15

Graphics 

Draw with a Canvas / On a View 

If you're application does not require a significant amount of processing or frame-rate speed (perhaps 

for a chess game, a snake game, or another slowly-animated application), then you should consider 

creating a custom View component and drawing with a Canvas in View.onDraw(). 

The most convenient aspect of doing so is that the Android framework will provide you with a predefined 

Canvas to which you will place your drawing calls. 

To start, extend the View class (or descendent thereof) and define the onDraw() callback method. This 

method will be called by the Android framework to request that your View draw itself. This is where 

you will perform all your calls to draw through the Canvas, which is passed to you through the 

onDraw() callback. 


16

Graphics 

Draw with a Canvas / On a View (cont.) 

The Android framework will only call onDraw() as necessary. Each time that your application is 

prepared to be drawn, you must request your View be invalidated by calling invalidate(). This indicates 

that you'd like your View to be drawn and Android will then call your onDraw() method (though is not 

guaranteed that the callback will be instantaneous). 

Inside your View component's onDraw(), use the Canvas given to you for all your drawing, using 

various Canvas.draw...() methods, or other class draw() methods that take your Canvas as an 

argument. Once your onDraw() is complete, the Android framework will use your Canvas to draw a 

Bitmap handled by the system. 

Note: In order to request an invalidate from a thread other than your main Activity's thread, you must 

call postInvalidate(). 

Also read Building Custom Components for a guide to extending a View class, and 2D Graphics: 

Drawables for information on using Drawable objects like images from your resources and other 

primitive shapes. 

For a sample application, see the Snake game, in the SDK samples folder: /samples/Snake/. 


17

Graphics 

Draw with a Canvas / On a SurfaceView 

The SurfaceView is a special subclass of View that offers a dedicated drawing surface within the 

View hierarchy. 

The aim is to offer this drawing surface to an application's secondary thread, so that the application 

isn't required to wait until the system's View hierarchy is ready to draw. 

Instead, a secondary thread that has reference to a SurfaceView can draw to its own Canvas at its 

own pace. 

To begin, you need to create a new class that extends SurfaceView. 

The class should also implement SurfaceHolder.Callback. 

This subclass is an interface that will notify you with information about the underlying Surface, such as 

when it is created, changed, or destroyed. 

These events are important so that you know when you can start drawing, whether you need to make 

adjustments based on new surface properties, and when to stop drawing and potentially kill some 

tasks. 

Inside your SurfaceView class is also a good place to define your secondary Thread class, which will 

perform all the drawing procedures to your Canvas. 


18

Graphics 

Draw with a Canvas / On a SurfaceView (cont.) 

Instead of handling the Surface object directly, you should handle it via a SurfaceHolder. 

So, when your SurfaceView is initialized, get the SurfaceHolder by calling getHolder(). You should 

then notify the SurfaceHolder that you'd like to receive SurfaceHolder callbacks (from 

SurfaceHolder.Callback) by calling addCallback() (pass it this). Then override each of the 

SurfaceHolder.Callback methods inside your SurfaceView class. 

In order to draw to the Surface Canvas from within your second thread, you must pass the thread your 

SurfaceHandler and retrieve the Canvas with lockCanvas(). You can now take the Canvas given to 

you by the SurfaceHolder and do your necessary drawing upon it. Once you're done drawing with the 

Canvas, call unlockCanvasAndPost(), passing it your Canvas object. The Surface will now draw the 

Canvas as you left it. 

Perform this sequence of locking and unlocking the canvas each time you want to redraw. 

Note: On each pass you retrieve the Canvas from the SurfaceHolder, the previous state of the Canvas 

will be retained. In order to properly animate your graphics, you must re-paint the entire surface. For 

example, you can clear the previous state of the Canvas by filling in a color with drawColor() or setting 

a background image with drawBitmap(). Otherwise, you will see traces of the drawings you previously 

performed. 

For a sample application, see the Lunar Landar game, in the SDK samples folder: /samples/LunarLander/. 

Or, browse the source in the Sample Code section. 


19

1. Graphics 



2D Graphics 

Overview 

Android offers a custom 2D graphics library for drawing and animating shapes and images. The 

android.graphics.drawable and android.view.animation packages are where you'll find the common 

classes used for drawing and animating in two-dimensions. 

This document offers an introduction to drawing graphics in your Android application. We'll discuss the 

basics of using Drawable objects to draw graphics, how to use a couple subclasses of the Drawable 

class, and how to create animations that either tween (move, stretch, rotate) a single graphic or 

animate a series of graphics (like a roll of film). 


21

2D Graphics 

Drawables 

A Drawable is a general abstraction for "something that can be drawn." You'll discover that the 

Drawable class extends to define a variety of specific kinds of drawable graphics, including 

BitmapDrawable, ShapeDrawable, PictureDrawable, LayerDrawable, and several more. Of course, 

you can also extend these to define your own custom Drawable objects that behave in unique ways. 

There are three ways to define and instantiate a Drawable: 

1. using an image saved in your project resouces; 

2. using an XML file that defines the Drawable properties; or 

3. using the normal class constructors. 

Below, we'll discuss each the first two techniques (using constructors is nothing new for an 

experienced developer). 


22

2D Graphics 

Drawables / Creating from resource images 

A simple way to add graphics to your application is by referencing an image file from your project 

resources. Supported file types are PNG (preferred), JPG (acceptable) and GIF (discouraged). This 

technique would obviously be preferred for application icons, logos, or other graphics such as those 

used in a game. 

To use an image resource, just add your file to the res/drawable/ directory of your project. From there, 

you can reference it from your code or your XML layout. Either way, it is referred using a resource ID, 

which is the file name without the file type extension (E.g., my_image.png is referenced as my_image). 

Example code 

The following code snippet demonstrates how to build an ImageView that uses an image from 

drawable resources and add it to the layout. 


23

2D Graphics 

LinearLayout mLinearLayout; 

protected void onCreate(Bundle savedInstanceState) { 

} 


// Create a LinearLayout in which to add the ImageView 

mLinearLayout = new LinearLayout(this); 

// Instantiate an ImageView and define its properties 

ImageView i = new ImageView(this); 

i.setImageResource(R.drawable.my_image); 

i.setAdjustViewBounds(true); // set the ImageView bounds to match the Drawable's dimensions 

i.setLayoutParams(new Gallery.LayoutParams(LayoutParams.WRAP_CONTENT, 

LayoutParams.WRAP_CONTENT)); 

// Add the ImageView to the layout and set the layout as the content view 

mLinearLayout.addView(i); 

setContentView(mLinearLayout); 


24

2D Graphics 


25

2D Graphics 

In other cases, you may want to handle your image resource as a Drawable object. To do so, create a 

Drawable from the resource like so: 

Drawable myImage = Resources.getDrawable(R.drawable.my_image); 

ImageView i= i new ImageView(this); 

Drawable myImage = getResources().getDrawable(R.drawable.android); 

// i.setImageResource(R.drawable.android); 

i.setImageDrawable(myImage); 

Example XML 

The XML snippet below shows how to add a resource Drawable to an ImageView in the XML layout 

(with ( some red tint just j for fun). ) 

 

For more information on using gpproject j resources, , 

read about Resources and Assets. 


26

2D Graphics 


27

2D Graphics 

Drawables / Creating from resource XML 

By now, you should be familiar with Android's principles of developing a User Interface. Hence, you 

understand the power and flexibility inherent in defining objects in XML. This philosophy caries over 

from Views to Drawables. If there is a Drawable object that you'd like to create, which is not initially 

dependent on variables defined by your applicaton code or user interaction, then defining the 

Drawable in XML is a good option. 

Even if you expect your Drawable to change its properties during the user's experience with 

your application, you should consider defining the object in XML, as you can always modify 

properties once it is instantiated. 

Once you've defined your Drawable in XML, save the file in the res/drawable/ directory of your project. 

Then, retrieve and instantiate the object by calling Resources.getDrawable(), passing it the resource 

ID of your XML file. (See the example below.) 

Any Drawable subclass that supports the inflate() method can be defined in XML and instantiated by 

your application. Each Drawable that supports XML inflation utilizes specific XML attributes that help 

define the object properties (see the class reference to see what these are). See the class 

documentation for each Drawable subclass for information on how to define it in XML. 


28

2D Graphics 

Example 

Here's Here s some XML that defines a TransitionDrawable: 

 

 

 

With this XML saved in the file res/drawable/expand_collapse.xml, the following code will instantiate 

the TransitionDrawable and set it as the content of an ImageView: 

Resources res = mContext.getResources(); 

TransitionDrawable transition 

=(TransitionDrawable) = (TransitionDrawable) res res.getDrawable(R.drawable.expand_collapse); 

getDrawable(R drawable expand collapse); 

ImageView image = (ImageView) findViewById(R.id.toggle_image); 

image.setImageDrawable(transition); 

Then this transition can be run forward (for 1 second) with: 

transition.startTransition(1000); 

Refer to the Drawable classes listed above for more information on the XML attributes supported by 

each. 


29

2D Graphics 


30

2D Graphics 

ShapeDrawable 

When you want to dynamically draw some two-dimensional graphics, a ShapeDrawable object 

will probably suit your needs. With a ShapeDrawable, you can programmatically draw primitive shapes 

and style them in any way imaginable. 

A ShapeDrawable is an extension of Drawable, so you can use one where ever a Drawable is 

expected - perhaps for the background of a View, set with setBackgroundDrawable(). Of course, you 

can also draw your shape as its own custom View, to be added to your layout however you please. 

Because the ShapeDrawable has its own draw() method, you can create a subclass of View that 

draws the ShapeDrawable during the View.onDraw() method. 

Here's a basic extension of the View class that does just this, to draw a ShapeDrawable as a View: 


31

2D Graphics 

public class CustomDrawableView extends View { 

} 

private ShapeDrawable mDrawable; 

public CustomDrawableView(Context context) { 


} 

int x = 10; 

int y = 10; 

int width = 300; 

int height = 50; 

mDrawable = new ShapeDrawable(new OvalShape()); 

mDrawable.getPaint().setColor(0xff74AC23); 

mDrawable.setBounds(x, y, x + width, y + height); 

protected void onDraw(Canvas canvas) { 

mDrawable.draw(canvas); 

} 


32

2D Graphics 

In the constructor, a ShapeDrawable is defines as an OvalShape. It's then given a color and the 

bounds of the shape are set. If you do not set the bounds, then the shape will not be drawn, whereas if 

you don't set the color, it will default to black. 

With the custom View defined, it can be drawn any way you like. With the sample above, we can draw 

the shape progammatically in an Activity: 

CustomDrawableView mCustomDrawableView; 

protected void onCreate(Bundle savedInstanceState) { 


View mCustomDrawableView = new CustomDrawableView(this); 

} 

setContentView(mCustomDrawableView); 


33

2D Graphics 


34

2D Graphics 

If you'd like to draw this custom drawable from the XML layout instead of from the Activity, then the 

CustomDrawable class must override the View(Context, AttributeSet) constructor, which is called 

when instantiating a View via inflation from XML. Then add a CustomDrawable element to the XML, 

like so: 

 

The ShapeDrawable class (like many other Drawable types in the android.graphics.drawable package) 

allows you to define various properties of the drawable with public methods. Some properties you 

might want to adjust include alpha transparency, color filter, dither, opacity and color. 


35

2D Graphics 

NinePatchDrawable 

A NinePatchDrawable graphic is a stretchable bitmap image, which Android will automatically 

resize to accomodate the contents of the View in which you have placed it as the background. An 

example use of a NinePatch is the backgrounds used by standard Android buttons - buttons must 

stretch to accommodate strings of various lengths. A NinePatch drawable is a standard PNG image 

that includes an extra 1-pixel-wide border. It must be saved with the extension .9.png, and saved 

into the res/drawable/ directory of your project. 

The border is used to define the stretchable and static areas of the image. You indicate a stretchable 

section by drawing one (or more) 1-pixel-wide black line(s) in the left and top part of the border. (You 

can have as many stretchable sections as you want.) The relative size of the stretchable sections 

stays the same, so the largest sections always remain the largest. 

You can also define an optional drawable section of the image (effectively, the padding lines) by 

drawing a line on the right and bottom lines. If a View object sets the NinePatch as its background 

and then specifies the View's text, it will stretch itself so that all the text fits inside only the area 

designated by the right and bottom lines (if included). If the padding lines are not included, 

Android uses the left and top lines to define this drawable area. 

To clarify the difference between the different lines, the left and top lines define which pixels of the 

image are allowed to be replicated in order to strech the image. The bottom and right lines define the 

relative area within the image that the contents of f the View are allowed to lie within. 


36

2D Graphics 

Here is a sample NinePatch file used to define a button: 

This NinePatch defines one stretchable area with the left and top lines and the drawable area with the 

bottom and right lines. In the top image, the dotted grey lines identify the regions of the image that will 

be replicated in order to strech the image. The pink rectangle in the bottom image identifies the region 

in which the contents of the View are allowed. If the contents don't fit in this region, then the image will 

be stretched so that they do. 

The Draw 9-patch tool offers an extremely handy way to create your NinePatch images, using a 

WYSIWYG graphics editor. It even raises warnings if the region you've defined for the stretchable area 

is at risk of producing drawing artifacts as a result of the pixel replication. 


37

2D Graphics 

NinePatchDrawable / Example XML 

Here's some sample layout XML that demonstrates how to add a NinePatch image to a couple of 

buttons. (The NinePatch image is saved as res/drawable/my_button_background.9.png 

 

 

Note that the width and height are set to "wrap_content" to make the button fit neatly around the text. 


38

2D Graphics 

Tween Animation 

A tween animation can perform a series of simple transformations (position, size, rotation, and 

transparency) on the contents of a View object. So, if you have a TextView object, you can move, 

rotate, grow, or shrink the text. If it has a background image, the background image will be 

transformed along g with the text. The animation ppackage g pprovides 

all the classes used in a tween 

animation. 

A sequence of animation instructions defines the tween animation, defined by either XML or 

Android code. Like defining g a layout, y an XML file is recommended because it's more readable, 

reusable, and swappable than hard-coding the animation. In the example below, we use XML. (To 

learn more about defining an animation in your application code, instead of XML, refer to the 

AnimationSet class and other Animation subclasses.) 

The animation instructions define the transformations that you want to occur, when they will occur, and 

how long they should take to apply. Transformations can be sequential or simultaneous - for example, 

you can have the contents of a TextView move from left to right, and then rotate 180 degrees, or you 

can have the text move and rotate simultaneously. Each transformation takes a set of parameters 

specific for that transformation (starting size and ending size for size change, starting angle and 

ending angle for rotation, and so on), and also a set of common parameters (for instance, start time 

and duration). To make several transformations happen simultaneously, give them the same start 

time; to make them sequential, calculate the start time plus the duration of the preceding 

transformation. 


39

2D Graphics 

Tween Animation (cont.) 

The animation XML file belongs in the res/anim/ directory of your Android project. 

The file must have a single root element: this will be either a single , , , 

, interpolator p element, or element that holds groups g p of these elements ( (which may y 

include another ). 

By default, all animation instructions are applied simultaneously. 

To make them occur sequentially, q y you y must specify p y the startOffset attribute, as shown in the 

example below. 

The following XML from one of the ApiDemos is used to stretch, then simultaneously spin and rotate a 

View object. 


40

2D Graphics 

 

 

 

 

 

 


41

2D Graphics 

Screen coordinates (not used in this example) are (0,0) at the upper left hand corner, and increase as 

you go down and to the right. 

Some values, such as pivotX, can be specified relative to the object itself or relative to the parent. Be 

sure to use the proper format for what you want ("50" for 50% relative to the parent, or "50%" for 50% 

relative to itself). 

You can determine how a transformation is applied over time by assigning an Interpolator. 

Android includes several Interpolator subclasses that specify various speed curves: for instance, 

AccelerateInterpolator p tells a transformation to start slow and speed p up. p Each one has an attribute 

value that can be applied in the XML. 

With this XML saved as hyperspace_jump.xml in the res/anim/ directory of the project, the following 

Java code will reference it and apply pp y it to an ImageView g object j from the layout. y 

ImageView spaceshipImage = (ImageView) findViewById(R.id.spaceshipImage); 

Animation hyperspaceJumpAnimation 

= AnimationUtils.loadAnimation(this, ( , R.anim.hyperspace yp p _jjump); p); 

spaceshipImage.startAnimation(hyperspaceJumpAnimation); 

As an alternative to startAnimation(), you can define a starting time for the animation with 

Animation.setStartTime(), (), then assign g the animation to the View with View.setAnimation(). () 


42

2D Graphics 


43

2D Graphics 

Frame Animation 

This is a traditional animation in the sense that it is created with a sequence of different 

images, played in order, like a roll of film. The AnimationDrawable class is the basis for frame 

animations. While you can define the frames of an animation in your code, using the 

AnimationDrawable class API, it's more simply pyaccomplished p with a single g XML file that lists the 

frames that compose the animation. Like the tween animation above, the XML file for this kind of 

animation belongs in the res/anim/ directory of your Android project. In this case, the instructions are 

the order and duration for each frame of the animation. 

The XML file consists of an element as the root node and a series of child 

nodes that each define a frame: a drawable resource for the frame and the frame duration. Here's an 

example XML file for a frame-by-frame animation: 

 

 

 

 

 

This animation runs for just three frames. By setting the android:oneshot attribute of the list to true, it 

will cycle just once then stop and hold on the last frame. If it is set false then the animation will loop. 


44

2D Graphics 

With this XML saved as rocket_thrust.xml in the res/anim/ directory of the project, it can be added as 

the background image to a View and then called to play. 

Here's an example Activity, in which the animation is added to an ImageView and then animated when 

the screen is touched: 

AnimationDrawable at o a ab e rocketAnimation; 

oc et at o ; 

public void onCreate(Bundle savedInstanceState) { 


setContentView(R.layout.main); 

( y ); 

} 

ImageView rocketImage = (ImageView) findViewById(R.id.rocket_image); 

rocketImage.setBackgroundResource(R.anim.rocket_thrust); 

rocketAnimation = (AnimationDrawable) ( ) rocketImage.getBackground(); 

g g g (); 

public boolean onTouchEvent(MotionEvent event) { 

if (event.getAction() ( g () == MotionEvent.ACTION_ DOWN) ){ { 

rocketAnimation.start(); 

return true; 

} 

return super.onTouchEvent(event); 

p ( ); 

} 


45

2D Graphics 

It's It s important to note that the start() method called on the AnimationDrawable cannot be called 

during the onCreate() method of your Activity, because the AnimationDrawable is not yet fully 

attached to the window. 

If you want to play the animation immediately immediately, without requiring interaction interaction, then you might want to call 

it from the onWindowFocusChanged() method in your Activity, which will get called when Android 

brings your window into focus. 


46

2D Graphics 


47

1. Graphics 



3D with OpenGL 

Overview 

Android includes support for high performance 3D graphics via the OpenGL API - specifically, the 

OpenGL ES API. 

OpenGL p ES is a flavor of the OpenGL p specification p intended for embedded devices. 

Versions of OpenGL ES are loosely peered to versions of the primary OpenGL standard. 

Android currently supports OpenGL ES 1.0, which corresponds to OpenGL 1.3. 

So, if the application you have in mind is possible with OpenGL 1.3 on a desktop system, it should be 

possible p on Android. 

The specific API provided by Android is similar to the J2ME JSR239 OpenGL ES API. 

However, it may not be identical, so watch out for deviations. 


49


Using the API 

Here's how to use the API at an extremely high level: 

1. Write a custom View subclass. 

2. Obtain a handle to an OpenGLContext, p which provides p access to the OpenGL p functionality. y 

3. In your View's onDraw() method, get a handle to a GL object, and use its methods to 

perform GL operations. 

For an example p of this usage g model ( (based on the classic GL ColorCube), ) 

see com.android.samples.graphics.GLSurfaceView.java in the ApiDemos sample code project. 

A slightly more sophisticated version showing how to use it with threads can be found in 

com.android.samples.graphics.GLSurfaceViewActivity.java. 

Writing a summary of how to actually write 3D applications using OpenGL is beyond the scope of this 

text and is left as an exercise for the reader. 


50


Links to Additional Information 

Information about OpenGL ES can be found at http://www.khronos.org/opengles/. 

Information specifically about OpenGL ES 1.0 (including a detailed specification) can be found at 

http://www.khronos.org/opengles/1_X/. 

p g p g _ 

The documentation for the Android OpenGL ES implementations are also available. 

Finally, y note that though g Android does include some basic support pp for OpenGL p ES 1.1, 

the support is not complete, and should not be relied upon at this time. 


51


Understanding 3D graphics 

Android provides a three three-dimensional dimensional graphics library based on the OpenGL ES standard 


52


Introducing OpenGL 

OpenGL1 was developed by Silicon Graphics Inc. in 1992. It provides a unified interface for 

programmers to take advantage of hardware from any manufacturer. At its core, OpenGL implements 

familiar concepts like viewports and lighting, and tries to hide most of the hardware layer from the 

developer developer. 

Because it was designed for workstations, OpenGL is too large to fit on a mobile device. So, Android 

implements a subset of OpenGL called OpenGL ES (OpenGL for Embedded Systems).2 This 

standard was created by the Khronos Group Group, an industry consortium of companies like Intel Intel, AMD AMD, 

Nvidia, Nokia, Samsung, and Sony. The same library (with minor differences) is now available on 

major mobile platforms including Android, Symbian, and iPhone. 

Every language has its own language bindings for OpenGL ES ES, and Java is no exception exception. Java’s Java s 

language binding was defined by a Java Specification Request (JSR239).3 Android implements this 

standard as closely as possible, so you can refer to a variety of books and documentation on JSR239 

and OpenGL ES for a full description of all its classes and methods. 

- “hello, android” 중에서. 


53


Introducing OpenGL (cont.) 

What is OpenGL ES? 

• Royalty-free, cross-platform API for full-function 2D and 3D graphics on embedded system 

• 3D API for Symbian, Android, iPhone, etc 

• Stripped down version of OpenGL 

– Standard specification for cross-language, cross-platform API for 2D & 3D graphics 

– About 150 commands specifying objects and operations 


54


Building an OpenGL Application 

package org.kandroid.example.opengl; 

import android.app.Activity; 

import android.os.Bundle; 

public class OpenGL extends Activity { 

} 

private GLSurfaceView mGLSurfaceView; 

@Override 

protected p void onCreate(Bundle ( savedInstanceState) ){ { 

} 


mGLSurfaceView = new GLSurfaceView(this); ( ); 

setContentView(mGLSurfaceView); 


55


public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback { 

// 

} 

private GLThread mGLThread; 

public GLSurfaceView(Context context) { 


getHolder() getHolder().addCallback(this); 

addCallback(this); 

getHolder().setType(SurfaceHolder.SURFACE_TYPE_GPU); 

} 

public void surfaceCreated(SurfaceHolder holder) { 

mGLThread = new GLThread(this); 

mGLThread.start(); 

} 

public void surfaceDestroyed(SurfaceHolder holder) { 

mGLThread.requestExitAndWait(); 

mGLThread = null; 

} 

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { 

} 


56


1. SurfaceView - a special kind of view that is used for 3D graphics. Extend this for any view that 

uses OpenGL. 

2. Surface - a place for drawing, like a Canvas, except it is implemented by the 3D hardware (if 

any). The Surface will be created when your OpenGL activity is running in the foreground, and 

destroyed when the activity exits or some other activity comes to the foreground. 

3. SurfaceHolder - an instance of this class is always there even if the Surface that it holds goes 

away. 

44. SurfaceHolder SurfaceHolder.Callback Callback - a SurfaceView implements this interface so OpenGL will notify it 

when the view’s Surface is created, destroyed, or resized. 

- Hello Android 중에서 중에서. 


57


Managing the threads 

} 

class GLThread extends Thread { 

private final GLSurfaceView view; 

GLThread(GLSurfaceView ( view) ){ { 

this.view = view; 

} 

@Override 

public void run() { 

// Loop until asked to quit 

while (!done) { 

// Draw a single frame here... 

} 

} 

public void requestExitAndWait() { 

try { 

join(); 

} catch (InterruptedException ex) { 

Thread.currentThread().interrupt(); 

} 

} 


58


// Initialize OpenGL... 

EGL10 egl = (EGL10) EGLContext EGLContext.getEGL(); getEGL(); 

EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY); 

int[] version = new int[2]; 

egl egl.eglInitialize(display, eglInitialize(display version); 

int[] configSpec = { EGL10.EGL_RED_SIZE, 5, 

EGL10.EGL_GREEN_SIZE, 6, EGL10.EGL_BLUE_SIZE, 5, 

EGL10 EGL10.EGL_DEPTH_SIZE, EGL DEPTH SIZE 16, 16 EGL10.EGL_NONE EGL10 EGL NONE }; 

EGLConfig[] configs = new EGLConfig[1]; 

int[] numConfig = new int[1]; 

egl egl.eglChooseConfig(display, eglChooseConfig(display configSpec configSpec, configs configs, 11, numConfig); 

EGLConfig config = configs[0]; 

EGLContext glc = egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, null); 

EGLSurface surface = egl.eglCreateWindowSurface(display, config, view.getHolder(), null); 

egl.eglMakeCurrent(display, surface, surface, glc); 

GL10 gl = (GL10) (glc.getGL()); 

(glc getGL()); 


59


init(gl); 

// Loop until asked to quit 

while (!done) { 

// Draw a single frame here... 

drawFrame(gl); 

egl egl.eglSwapBuffers(display, eglSwapBuffers(display surface); 

} 

// Error handling 

if (egl.eglGetError() == EGL11.EGL_CONTEXT_LOST) { 

Context c = view view.getContext(); 

getContext(); 

if (c instanceof Activity) { 

((Activity) c).finish(); 

} 

} 

// Free OpenGL resources 

egl egl.eglMakeCurrent(display, eglMakeCurrent(display EGL10.EGL_NO_SURFACE, 

EGL10 EGL NO SURFACE 

EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT); 

egl.eglDestroySurface(display, surface); 

egl.eglDestroyContext(display, glc); 

egl egl.eglTerminate(display); 

eglTerminate(display); 


60


private void init(GL10 gl) { 

} 

// Define the view frustrum 

gl.glViewport(0, 0, view.getWidth(), view.getHeight()); 

gl.glMatrixMode(GL10.GL_PROJECTION); 

gl gl.glLoadIdentity(); 

glLoadIdentity(); 

float ratio = (float) view.getWidth() / view.getHeight(); 

GLU.gluPerspective(gl, 45.0f, ratio, 1, 100f); 

// Set up any other options we need 

gl.glEnable(GL10.GL_DEPTH_TEST); 

gl.glDepthFunc(GL10.GL_LEQUAL); 

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 

private void drawFrame(GL10 gl) { 

// Clear the screen to black 

gl.glClear(GL10.GL_COLOR_BUFFER_BIT 

| GL10.GL_DEPTH_BUFFER_BIT); 

} 


61


glEnable() 

GL_BLEND 

Blend the incoming color values with the values already in the color buffer. 

GL_CULL_FACE 

Ignore polygons based on their winding (clockwise or counter-clockwise) counter clockwise) in window coordinates. 

This is a cheap way to eliminate back faces. 

GL_DEPTH_TEST 

Do depth comparisons and update the depth buffer. Pixels further away than those already 

drawn will be ignored. g 

GL_LIGHT 

Include light number i when figuring out an object’s brightness and color. 

GL_LIGHTING 

Turn on lighting g g and material calculations. 

GL_LINE_SMOOTH 

Draw anti-aliased lines (lines without jaggies). 

GL_MULTISAMPLE 

Perform multi-sampling p g for anti-aliasing g and other effects. 

GL_POINT_SMOOTH 

Draw anti-aliased points. 

GL_TEXTURE_2D 

Use textures to draw surfaces. 


62



63


Building a model 

class Cube 

{ 

private final IntBuffer mVertexBuffer; 

public Cube() { 

} 

int one = 65536; 

int half = one / 2; 

int vertices[] = { 

-half, half -half, half half half, half half, -half, half half half, -half, half half half, half half, half half, half half, half half, // FRONT 

-half, -half, -half, -half, half, -half, half, -half, -half, half, half, -half, // BACK 

-half, -half, half, -half, half, half, -half, -half, -half, -half, half, -half, // LEFT 

half, -half, -half, half, half, -half, half, -half, half, half, half, half, // RIGHT 

-half, half half half, half half, half half, half half, half half, -half, half half half, -half, half half half, half half, -half, half // TOP 

-half, -half, half, -half, -half, -half, half, -half, half, half, -half, -half, // BOTTOM}; 

ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4); 

vbb vbb.order(ByteOrder.nativeOrder()); 

order(ByteOrder nativeOrder()); 

mVertexBuffer = vbb.asIntBuffer(); 

mVertexBuffer.put(vertices); 

mVertexBuffer.position(0); 


64


} 

public void draw(GL10 gl) { 

gl gl.glVertexPointer(3, glVertexPointer(3 GL10.GL_FIXED, GL10 GL FIXED 00, mVertexBuffer); 

} 

gl.glColor4f(1, 1, 1, 1); 

gl.glNormal3f(0, 0, 1); 

gl gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, glDrawArrays(GL10 GL TRIANGLE STRIP 0, 0 4); 

gl.glNormal3f(0, 0, -1); 

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 4, 4); 

gl gl.glColor4f(1, glColor4f(1 1, 1 1, 1 1); 

gl.glNormal3f(-1, 0, 0); 




gl.glColor4f(1, 1, 1, 1); 



gl.glNormal3f(0, -1, 0); 



65



// Clear the screen to black 

gl.glClear(GL10.GL_COLOR_BUFFER_BIT 

| GL10.GL_DEPTH_BUFFER_BIT); 

} 

// Position model so we can see it 

gl.glMatrixMode(GL10.GL_MODELVIEW); 

gl.glLoadIdentity(); 

gl.glTranslatef(0, 0, -3.0f); 

// Other drawing commands go here... 

cube.draw(gl); 


66



67


Lights, Camera, … 

// Define the lighting 

float lightAmbient[] = new float[] { 0.2f, 0 2f 00.2f, 2f 00.2f, 2f 1 }; 

float lightDiffuse[] = new float[] { 1, 1, 1, 1 }; 

float[] lightPos = new float[] { 1, 1, 1, 1 }; 

gl gl.glEnable(GL10.GL_LIGHTING); 

glEnable(GL10 GL LIGHTING); 

gl.glEnable(GL10.GL_LIGHT0); 

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0); 

gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse, 0); 

gl gl.glLightfv(GL10.GL_LIGHT0, glLightfv(GL10 GL LIGHT0 GL10.GL_POSITION, GL10 GL POSITION lightPos lightPos, 0); 

// What is the cube made of? 

float matAmbient[] = new float[] { 1, 1, 1, 1 }; 

float matDiffuse[] = new float[] { 11, 11, 11, 1 }; 

gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT,matAmbient, 0); 

gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE,matDiffuse, 0); 


68


All 3D graphics libraries support three types of lighting: 

• ambient —a general glow that the light contributes to the entire scene, even to objects facing away 

from the light. It’s important to have a little ambient light so you can pick out details even in the 

shadows. 

• diffuse —soft directional lighting, as you might get from a flourescent panel. Most of the light 

contributed to your scene will typically come from diffuse sources. 

• specular p —shiny y light, g , usually y from bright g ppoint sources. Combined with shiny y materials this ggives 

you highlights (glints) that add realism. 

- Hello Android 중에서 


69



70


Action 

private long startTime; 


startTime = System.currentTimeMillis(); 

} 


// ... Set rotation angle based on the time 

long elapsed = System.currentTimeMillis() - startTime; 

gl gl.glRotatef(elapsed glRotatef(elapsed * (30f / 1000f) 1000f), 00, 11, 0); 

gl.glRotatef(elapsed * (15f / 1000f), 1, 0, 0); 

} 


71



72


Applying texture 

private final IntBuffer mTextureBuffer; 

public Cube() { 

int texCoords[] = { 

0, one, one, one, 0, 0, one, 0, // FRONT 

one one, one one, one one, 00, 00, one one, 00, 0 0, // BACK 

one, one, one, 0, 0, one, 0, 0, // LEFT 

one, one, one, 0, 0, one, 0, 0, // RIGHT 

one, 0, 0, 0, one, one, 0, one, // TOP 

00, 00, 00, one one, one one, 00, one one, one one, // BOTTOM }; 

ByteBuffer tbb = ByteBuffer.allocateDirect(texCoords.length * 4); 

tbb.order(ByteOrder.nativeOrder()); 

mTextureBuffer = tbb tbb.asIntBuffer(); 

asIntBuffer(); 

mTextureBuffer.put(texCoords); 

mTextureBuffer.position(0); 

} 

static void loadTexture(GL10 gl gl, Context context context, int resource) { 

Bitmap bmp = BitmapFactory.decodeResource( 

context.getResources(), resource); 

ByteBuffer bb = extract(bmp); 

load(gl load(gl, bb bb, bmp bmp.getWidth(), getWidth() bmp bmp.getHeight()); 

getHeight()); 

} 


73


private static ByteBuffer extract(Bitmap bmp) { 

ByteBuffer bb = ByteBuffer.allocateDirect(bmp.getHeight() * bmp.getWidth() * 4); 

bb bb.order(ByteOrder.BIG_ENDIAN); 

order(ByteOrder BIG ENDIAN); 

IntBuffer ib = bb.asIntBuffer(); 

} 

// Convert ARGB -> RGBA 

for (int y=bmp y = bmp.getHeight() getHeight() - 1; y > -1; 1; y y--) ) 

for (int x = 0; x < bmp.getWidth(); x++) { 

int pix = bmp.getPixel(x, bmp.getHeight() - y - 1); 

// int alpha = ((pix >> 24) & 0xFF); 

int red = ((pix >> 16) & 0xFF); 

int green = ((pix >> 8) & 0xFF); 

int blue = ((pix) & 0xFF); 

// Make up alpha for interesting effect 

ib.put(red


private static void load(GL10 gl, ByteBuffer bb, int width, int height) { 

// Get a new texture name 

int[] tmp tmp_tex tex = new int[1]; 

gl.glGenTextures(1, tmp_tex, 0); 

int tex = tmp_tex[0]; 

} 

// Load it up 

gl.glBindTexture(GL10.GL_TEXTURE_2D, tex); 

gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_RGBA, 

width width, height height, 00, GL10 GL10.GL_RGBA, 

GL RGBA 

GL10.GL_UNSIGNED_BYTE, bb); 

gl.glTexParameterx(GL10.GL_TEXTURE_2D, 

GL10 GL10.GL_TEXTURE_MIN_FILTER, GL TEXTURE MIN FILTER GL10.GL_LINEAR); 

GL10 GL LINEAR); 

gl.glTexParameterx(GL10.GL_TEXTURE_2D, 

GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR); 


75


public void draw(GL10 gl) { 

gl gl.glTexCoordPointer(2, glTexCoordPointer(2 GL10.GL_FIXED, GL10 GL FIXED 00, mTextureBuffer); 

} 


} 

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY); 

gl.glEnable(GL10.GL_TEXTURE_2D); 

cube.loadTexture(gl, view.getContext(), R.drawable.android); 


76



77


Peekaboo 

boolean SEE_THRU = true; 

// ... 

if (SEE_THRU) { 

gl gl.glDisable(GL10.GL_DEPTH_TEST); 

glDisable(GL10 GL DEPTH TEST); 

gl.glEnable(GL10.GL_BLEND); 

gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE); 

} 


78



79

질의및응답 


80

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

Audio & Video, Location, Dev. Tools 

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

11. Audio and Video 

22. Location 

33. DDevelopment l TTools l 


82

Audio and Video 

Overview 

The Android platform offers built-in encoding/decoding for a variety of common media types, so 

that you can easily integrate audio, video, and images into your applications. Accessing the 

platform's media capabilities is fairly straightforward ? you do so using the same intents and 

activities ti iti mechanism h i th that t th the rest t of f Android A d id uses. 

Android lets you play audio and video from several types of data sources. You can play audio or 

video from media files stored in the application's resources (raw resources), from standalone 

fil files in i th the fil filesystem, t or from f a data d t stream t arriving i i over a network t k connection. ti To T play l audio di or 

video from your application, use the MediaPlayer class. 

The platform also lets you record audio, where supported by the mobile device hardware. 

Recording of video ideo is not ccurrently rrentl ssupported, pported but b t is planned for a ffuture t re release release. To record aaudio, dio 

use the MediaRecorder class. Note that the emulator doesn't have hardware to capture audio, 

but actual mobile devices are likely to provide these capabilities that you can access through 

MediaRecorder. 

For a list of the media formats for which Android offers built-in support, see the Android Media 

Formats appendix. 


83


Android Supported Media Formats (Core Media Formats) 

TType FFormat E D DDetails il Fil File Type(s) T ( ) SSupported d 

Audio AAC LC/LTP 

HE-AACv1(AAC+) 

X 

Mono/Stereo content in any combinatio 

X n of standard bit rates up to 160 kbps a 

3GPP (.3gp) and MPEG-4 

(.mp4, .m4a). No support 

HE-AACv2 (enhanced AAC+) X nd sampling rates from 8 to 48kHz for raw AAC (.aac) 

AMR-NB X X 4.75 to 12.2 kbps sampled @ 8kHz 3GPP (.3gp) 

AMR-WB X 

9 rates from 6.60 kbit/s to 23.85 kbit/s s 

ampled @ 16kHz 

3GPP (.3gp) 

MP3 X Mono/Stereo 8-320Kbps constant (CBR MP3 X MP3 ( (.mp3) mp3) 

)or variable bit-rate (VBR) 

MIDI Type 0 and 1. DLS Version 1 and 

2. XMF and Mobile XMF. Support for rin 

gtone formats RTTTL/RTX, OTA, and i 

Melody 


Type 0 and 1 (.mid, .xmf, . 

mxmf). Also RTTTL/RTX ( 

MIDI X 

.rtttl, .rtx), OTA (.ota), and 

Melody iMelody (.imy) 

Ogg Vorbis X Ogg (.ogg) 

PCM/WAVE 

8- and 16-bit linear PCM (rates up to lim 

X 

it of hardware) 

WAVE (.wav) 

Image JPEG X X base+progressive JPEG (.jpg) 

GIF X GIF ( (.gif) if) 

PNG X PNG (.png) 

BMP X BMP (.bmp) 

Video H.263 X X 3GPP (.3gp) 

HH.264 264 X X 

3GPP (.3gp) and MPEG-4 

(.mp4) 

MPEG4 SP 3GPP (.3gp) 

84


Android Supported Media Formats (T-Mobile G1 Media Formats) 

Type Format E D Details File Type(s) Supported 

Audio WMA X 

Audio Supports WMA standard L1-L3: 

L1: 64 kbps - 161 kbps @ 44.1kHz 

L2:


Audio and Video Playback 

Media can be played from anywhere: from a raw resource, from a file from the system, or from 

an available network (URL). 

YYou can play l bback k th the audio di ddata t only l tto th the standard t d d output t t ddevice; i currently, tl th that t iis th the mobile bil 

device speaker or Bluetooth headset. You cannot play sound files in the conversation audio. 


86


Audio and Video Playback / Playing from a Raw Resource 

Perhaps the most common thing to want to do is play back media (notably sound) within your 

own applications. Doing this is easy: 

11. PPut t the th sound d (or ( other th media di resource) ) fil file iinto t th the res/raw / ffolder ld of f your project, j t where h th the 

Eclipse plugin (or aapt) will find it and make it into a resource that can be referenced from 

your R class 

22. CCreate t an instance i t of f MMediaPlayer, di Pl referencing f i that th t resource using i MMediaPlayer.create, di Pl t and d 

then call start() on the instance: 

MediaPlayer mp = MediaPlayer.create(context, R.raw.sound_file_1); 

mp mp.start(); start() 

To stop playback, call stop(). If you wish to later replay the media, then you must reset() and 

prepare() the MediaPlayer object before calling start() again. (create() calls prepare() the first 

time time.) ) 

To pause playback, call pause(). Resume playback from where you paused with start(). 


87


Audio and Video Playback / Playing from a File or Stream 

You can play back media files from the filesystem or a web URL: 

1. Create an instance of the MediaPlayer using new 

22. CCall ll setDataSource() tD t S () with ith a St String i containing t i i th the path th (l (local l fil filesystem t or URL) to t the th file fil 

you want to play 

3. First prepare() then start() on the instance: 

MMediaPlayer di Pl mp = new MMediaPlayer(); di Pl () 

mp.setDataSource(PATH_TO_FILE); 

mp.prepare(); 

mp.start(); 

stop() and pause() work the same as discussed above. 

Note: It is possible that mp could be null, so good code should null check after the new. Also, 

IllegalArgumentException and IOException either need to be caught or passed on when using 

setDataSource(), since the file you are referencing may not exist. 

Note: If you're passing a URL to an online media file, the file must be capable of progressive 

download download. 


88


Audio Capture 

Audio capture from the device is a bit more complicated than audio/video playback, but still fairly 

simple: 

1. Create a new instance of android.media.MediaRecorder using new 

2. Create a new instance of android.content.ContentValues and put in some standard 

properties like TITLE, TIMESTAMP, and the all important MIME_TYPE 

33. Create a file path for the data to go to (you can use android android.content.ContentResolver content ContentResolver to 

create an entry in the Content database and get it to assign a path automatically which you 

can then use) 

4. Set the audio source using MediaRecorder.setAudioSource(). You will probably want to use 

MediaRecorder.AudioSource.MIC 

5. Set output file format using MediaRecorder.setOutputFormat() 

6. Set the audio encoder using MediaRecorder.setAudioEncoder() 

77. Call prepare() on the MediaRecorder instance instance. 

8. To start audio capture, call start(). 

9. To stop audio capture, call stop(). 

10. When you are done with the MediaRecorder instance, call release() on it. 


89


Audio Capture / Example: Audio Capture Setup and Start 

recorder = new MediaRecorder(); 

ContentValues values = new ContentValues(3); 

values.put(MediaStore.MediaColumns.TITLE, SOME_NAME_HERE); 

values.put(MediaStore.MediaColumns.TIMESTAMP, System.currentTimeMillis()); 

values.put(MediaStore.MediaColumns.MIME_TYPE, recorder.getMimeContentType()); 

ContentResolver contentResolver = new ContentResolver(); 

Uri base = MediaStore.Audio.INTERNAL_CONTENT_URI; 

Uri newUri = contentResolver contentResolver.insert(base, insert(base values); 


90


Audio Capture / Example: Audio Capture Setup and Start (cont.) 

if (newUri == null) { 

// need to handle exception here - we were not able to create a new 

// content entry 

} 

String path = contentResolver.getDataFilePath(newUri); 

// could use setPreviewDisplay() to display a preview to suitable View here 

recorder.setAudioSource(MediaRecorder.AudioSource.MIC); 

recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); 

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); 

recorder.setOutputFile(path); 

recorder.prepare(); 

recorder.start(); 


91


Audio Capture / Stop Recording 

recorder.stop(); 

recorder.release(); 


92


Playback 

Audio / Video 

Record 

android android.media.MediaPlayer media MediaPlayer android android.media.MediaRecorder 

media MediaRecorder 


93


• Play y Media From: 

– Resource Folder 

– File System Path 

– URL 

• Basically 

– Create Ceaenew e instance sa ceoof MediaPlayer ed a aye 

– Call prepare() 

– Call start() 


94


Playback: MediaPlayer Class 

• Create Using: 

• Get: 

� Set: 

– URI 

– Position 

� Audio Stream 

– Resource ID 

– Duration 

�� Output Display 

– URI + Surface 

– FrameAt 

� Looping 

� Data Source 

• Others: O e s 

– Start 

�� Wake Mode 

– 

– 

Prepare 

Pause 

� Listeners: 

– 

– 

Release 

Reset 

Inherits from 

java.lang.Object 

�� 

Buffering Update 

Completion 

– SeekTo 

� Error 

– Stop � Wh When Prepared P d 


95


Recording: MediaRecorder 

• Create new instance of MediaRecorder 

• Create new instance of ContentValues 

• Create an output file 

• Set Preview Display 

• Set Video and Audio Source (Camera and Mic) 

• Set Properties (File Size, Video Size, Frame Rate) 

• Set Audio and Video Encoders 

• Call Prepare() and Start() 

• CCall ll St Stop() () and d RRelease() l () 


96


Uses of Media API 

• Call: 

– Receiving – Start mp3 background service 

– Automatically record conversation or 3G videos 

• Playing Games: 

– Sound mp3’s in background, render video in foreground 

– Clicking buttons sound small ticks (mp3’s) 

• Conference: 

– RRecording di and d Pl Playback b k of f MMobile bil CConference f 

– Synchronising Playback via Bluetooth on Projector 

• Record Sounds or Movements, Transform into Actions 


97

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. 


98

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 

iinstantiated t ti t d directly; di tl rather, th a handle h dl tto it should h ld bbe retrieved t i d via i 

getSystemService(Context.LOCATION_SERVICE). 

Once your application has a handle to the LocationManager, your application will be able to do three 

thi 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). 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 However, during initial development 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. 


99

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. 

UUsing i DDMS 

With the DDMS tool, you can simulate location data a few different ways: 

• MManually ll send d iindividual di id l llongitude/latitude it d /l tit d coordinates di t tto th the ddevice. i 

• 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 sing DDMS to spoof location data data, see the Using DDMS gguide. ide 


100

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 

di directory. t NNow 

you can use: 

• geo fix to send a fixed geo-location. 

Thi This command d accepts t a longitude l it d and d latitude l tit d in i decimal d i l ddegrees, and d an optional ti l altitude ltit d iin 

meters. 

For example: 

geo fi fix -121.45356 121 45356 46.51119 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 $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62 

081836 A 3751 65 S 14507 36 E 000 0 360 0 130998 011 3 E*62 


101

Location 

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 

llayout. t Note N t that, th t if you want t to t do d so, then th your Activity A ti it that th t handles h dl the th MMapView Vi must t extend t d 

MapActivity. 

Also note that you must obtain a MapView API Key from the Google Maps service, before your MapView 

can lload d maps ddata. t FFor more iinformation, f ti see Obt Obtaining i i a MMapView Vi API Key. K 

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

 


102

Sensor 

Sensor 

The Android SDK supports many different types of sensor devices, including: 

• SENSOR_ACCELEROMETER - measures acceleration in the X, Y, and Z axis. 

• SENSOR_LIGHT - tells you how bright your surrounding area is. 

• SENSOR_MAGNETIC_FIELD - returns magnetic attraction in the X, Y,and Z axis. 

• SENSOR_ORIENTATION - measures the yaw, pitch, and roll of the device. 

• SENSOR_ORIENTATION_RAW - same thing without filtering. 

• SENSOR_PROXIMITY - provides the distance between the sensor and some object. 

• SENSOR_TEMPERATURE - measures the temperature of the surrounding area. 

• SENSOR_TRICORDER - turns your device into a fully functional Star Trek Tricorder. 


103

질의및응답 


104

3D with OpenGL - 안드로이드 기술 커뮤니티 : Korea Android

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?