jsp XML whitespaces 없애는 방법 ECLIPSE

응답 받은 XML을 Parsing 도중 두줄의 빈 CR 때문에 파싱 오류가 생겼다.
그래서 찾아보니 jsp 상단에 단 한줄 

<%@ page trimDirectiveWhitespaces="true" %>

요렁게 하니 아무 문제 없이 잘된다.
이런것도 기술인가?

안드로이드 외부카메라 연결 2 ANDROID

SocketCamera.java (안드로이드 에뮬에서 구동 : CamClient로 동작) 

package com.example.socketcamera; 

import java.io.IOException;

import java.io.InputStream;

import java.net.InetSocketAddress;

import java.net.Socket; 

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Rect;

import android.hardware.Camera;

import android.hardware.Camera.Size;

import android.util.Log;

import android.view.SurfaceHolder; 

public class SocketCamera { 

             private static final String LOG_TAG = "SocketCamera:";

             private static final int SOCKET_TIMEOUT = 1000; 

             static private SocketCamera socketCamera;

             private CameraCapture capture;

             private Camera parametersCamera;

             private SurfaceHolder surfaceHolder; 

             //Set the IP address of your pc here!!

             private final String address = "192.168.10.12";

             private final int port = 5000; 

             private final boolean preserveAspectRatio = true;

             private final Paint paint = new Paint(); 

             private int width = 240;

             private int height = 320;

             private Rect bounds = new Rect(0, 0, width, height); 

             private SocketCamera()

Unknown macro: {                            //Just used so that we can pass Camera.Paramters in getters and setters                            parametersCamera = Camera.open();              }


             static public SocketCamera open()

             {

                           if (socketCamera == null)

Unknown macro: {                                         socketCamera = new SocketCamera();                            }


                           Log.i(LOG_TAG, "Creating Socket Camera");

                           return socketCamera;

             } 

             public void startPreview()

Unknown macro: {                            capture = new CameraCapture();                            capture.setCapturing(true);                            capture.start();                            Log.i(LOG_TAG, "Starting Socket Camera");\              }


             public void stopPreview()

Unknown macro: {                            capture.setCapturing(false);                            Log.i(LOG_TAG, "Stopping Socket Camera");              }


             public void setPreviewDisplay(SurfaceHolder surfaceHolder) throws IOException

Unknown macro: {                            this.surfaceHolder = surfaceHolder;              }


             public void setParameters(Camera.Parameters parameters)

Unknown macro: {                            //Bit of a hack so the interface looks like that of                            Log.i(LOG_TAG, "Setting Socket Camera parameters");                            parametersCamera.setParameters(parameters);                            Size size = parameters.getPreviewSize();                            bounds = new Rect(0, 0, size.width, size.height);              }

             public Camera.Parameters getParameters()

Unknown macro: {                            Log.i(LOG_TAG, "Getting Socket Camera parameters");                            return parametersCamera.getParameters();              }


             public void release()

Unknown macro: {                            Log.i(LOG_TAG, "Releasing Socket Camera parameters");                            //TODO need to implement this function              }



             private class CameraCapture extends Thread  { 

                           private boolean capturing = false; 

                           public boolean isCapturing()

Unknown macro: {                                         return capturing;                            }


                           public void setCapturing(boolean capturing)

Unknown macro: {                                         this.capturing = capturing;                            }


                           @Override

                           public void run() {

                                        while (capturing) {

                                                     Canvas c = null;

                                                     try {

                                                                  c = surfaceHolder.lockCanvas(null);

                                                                  synchronized (surfaceHolder) {

                                                                                Socket socket = null;

                                                                                try {

                                                                                             socket = new Socket();

                                                                                             socket.bind(null);

                                                                                             socket.setSoTimeout(SOCKET_TIMEOUT);

                                                                                             socket.connect(new InetSocketAddress(address, port), SOCKET_TIMEOUT); 

                                                                                             //obtain the bitmap

                                                                                             InputStream in = socket.getInputStream();

                                                                                             Bitmap bitmap = BitmapFactory.decodeStream(in); 

                                                                                             //render it to canvas, scaling if necessary

                                                                                             if (

                                                                                                                       bounds.right == bitmap.getWidth() &&

                                                                                                                       bounds.bottom == bitmap.getHeight())

Unknown macro: {                                                                                                           c.drawBitmap(bitmap, 0, 0, null);                                                                                              }

else {

                                                                                                          Rect dest;

                                                                                                          if (preserveAspectRatio)

Unknown macro: {                                                                                                                        dest = new Rect(bounds);                                                                                                                        dest.bottom = bitmap.getHeight() * bounds.right / bitmap.getWidth();                                                                                                                        dest.offset(0, (bounds.bottom - dest.bottom)/2);                                                                                                           }

else

Unknown macro: {                                                                                                                        dest = bounds;                                                                                                           }

                                                                                                          if (c != null)

                                                                                                         

Unknown macro: {                                                                                                                        c.drawBitmap(bitmap, null, dest, paint);                                                                                                           }

                                                                                             } 

                                                                                } catch (RuntimeException e)

Unknown macro: {                                                                                              e.printStackTrace();\                                                                                 }

catch (IOException e)

Unknown macro: {                                                                                              e.printStackTrace();                                                                                 }

finally {

                                                                                             try

Unknown macro: {                                                                                                           socket.close();                                                                                              }

catch (IOException e)

Unknown macro: {                                                                                                           /- ignore *-                                                                                              }

                                                                                }

                                                                  }

                                                     } catch (Exception e)

Unknown macro: {                                                                  e.printStackTrace();                                                     }

finally { 

                                                                  // do this in a finally so that if an exception is thrown

                                                                  // during the above, we don't leave the Surface in an

                                                                  // inconsistent state

                                                                  if (c != null)

Unknown macro: {                                                                                 surfaceHolder.unlockCanvasAndPost(c);                                                                   }

                                                     }

                                        }

                                        Log.i(LOG_TAG, "Socket Camera capture stopped");

                           }

             } 


CameraPreview.java (안드로이드 에뮬에서 구동) 

/-

 * Copyright (C) 2007 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 *- 

package com.example.socketcamera; 

import android.app.Activity;

import android.content.Context;

import android.hardware.Camera;

import android.os.Bundle;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

import android.view.Window;

import java.io.IOException; 

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

public class CameraPreview extends Activity {   

    private Preview mPreview; 

    @Override

             protected void onCreate(Bundle savedInstanceState)

Unknown macro: {         super.onCreate(savedInstanceState);\         // Hide the window title.         requestWindowFeature(Window.FEATURE_NO_TITLE);\         // Create our Preview view and set it as the content of our activity.         mPreview = new Preview(this);         setContentView(mPreview);     }



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

class Preview extends SurfaceView implements SurfaceHolder.Callback {

    SurfaceHolder mHolder;

    //Camera mCamera;

    SocketCamera mCamera; 

    Preview(Context context)

Unknown macro: {         super(context);\         // Install a SurfaceHolder.Callback so we get notified when the         // underlying surface is created and destroyed.         mHolder = getHolder();         mHolder.addCallback(this);         mHolder.setType(SurfaceHolder.SURFACE_TYPE_NORMAL);        // mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);     }


    public void surfaceCreated(SurfaceHolder holder) {

        // The Surface has been created, acquire the camera and tell it where

        // to draw.

        //mCamera = Camera.open();

           mCamera = SocketCamera.open();

        try

Unknown macro: {            mCamera.setPreviewDisplay(holder);         }

catch (IOException exception)

Unknown macro: {             mCamera.release();             mCamera = null;             // TODO}

    } 

    public void surfaceDestroyed(SurfaceHolder holder)

Unknown macro: {         // Surface will be destroyed when we return, so stop the preview.         // Because the CameraDevice object is not a shared resource, it's very         // important to release it when the activity is paused.         mCamera.stopPreview();         mCamera.release();         mCamera = null;     }


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

Unknown macro: {         // Now that the size is known, set up the camera parameters and begin         // the preview.         Camera.Parameters parameters = mCamera.getParameters();         parameters.setPreviewSize(w, h);         mCamera.setParameters(parameters);         mCamera.startPreview();     }


}


안드로이드 에뮬레이터에 외부 카메라 연결 ANDROID

증강현실 기능을 구현해야할 때 필요한 것들 

정보 1:

증강현실에 필요한 중요한 재료는 카메라일 것이다.

카메라에 2D 또는 3D로 Draw해서 어떤 방식으로든 그려놓은 개체에

이벤트를 받게하여 기능을 구현한다. 예로 들자면 그 개체가 도형이라면

손동작이 개체를 터치하는 순간 어떤 방향으로 어떻게 다시 그릴 것인가라는

로직이 나올 것이다.

필요한 도구가 무엇이 있는지 찾아본다. 

정보 2:

외부 캠 연결 방법

  1. JMF를 설치->실행->캠연결->JMF종료 후에 Webcambroadcaster.java를 실행
  2. Android-sdk가 설치된 디렉토리
    1. D:\android\platforms\android-2.1\samples\ApiDemos\src\com\example\android\apis\graphics 위치에 CameraPreview.java 및

SocketCamera.java 안드로이드 에뮬에서 실행. 

참조 사이트 및 정보 :

JMF(Java Media Framework) 다운로드 및 설치

1. download site  :  http://java.sun.com/javase/technologies/desktop/media/jmf/2.1.1/download.html

    2. 설치 하게 되면은 경로는 Program Files\JMF2.1.1e 로 잡히게 된다.

    3. 여기서 환경 변수를 잡아준다.

       변수 이름 : JMFHOME, 변수 값 : C:\JMF2.1.1

       변수 이름 : CLASSPATH, 변수 값 : %JMFHOME%\lib\jmf.jar;

    4. 설치된 JMF Studio로 연결된 device(camara)를 구동해 본다.

Android 외부 카메라 연동을 위한 소스를 제공하는 사이트

    http://www.tomgibara.com/android/camera-source

    5. JMF Studio에서 카메라가 인식됐다면 다음으로 할 일은 jmf.jar에서 제공하는

      Api로 카메라 인식 서버 프로그램을 작성해야 한다.

      찾아보니 이미 연동할 수 있게 소스가 마련되어 있었다.

위의 사이트에서 WebcamBroadcaster.java를 Eclipse에서 Java application으로 실행

6. 정보 2의 2를 에뮬에서 구동시키면 에뮬에서 외부 카메라가 인식되어 동작한다.

※ 중요한 점은 서버, 클라이언트로 구동되다보니 카메라가 연결된 PC의 IP를 클라이언트가 알아야 한다는 것이다. 클라이언트 소스를 보면

   IP를 셋팅하는 코드가 있다. 

샘플 코드 : 

WebcamBroadcaster.java (JavaApplication)

import java.awt.Dimension;

import java.awt.image.BufferedImage;

import java.io.BufferedOutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.Vector; 

import javax.imageio.ImageIO;

import javax.media.Buffer;

import javax.media.CannotRealizeException;

import javax.media.CaptureDeviceInfo;

import javax.media.CaptureDeviceManager;

import javax.media.Format;

import javax.media.Manager;

import javax.media.MediaLocator;

import javax.media.NoDataSourceException;

import javax.media.NoPlayerException;

import javax.media.Player;

import javax.media.control.FrameGrabbingControl;

import javax.media.format.RGBFormat;

import javax.media.format.VideoFormat;

import javax.media.protocol.CaptureDevice;

import javax.media.protocol.DataSource;

import javax.media.util.BufferToImage; 

--*

 * A disposable class that uses JMF to serve a still sequence captured from a

 * webcam over a socket connection. It doesn't use TCP, it just blindly

 * captures a still, JPEG compresses it, and pumps it out over any incoming

 * socket connection.

 *

 * @author Tom Gibara

 *

 -- 

public class WebcamBroadcaster { 

             public static boolean RAW = false; 

             private static javax.media.Player createPlayer(int width, int height) {

                           try {

                                        Vector<CaptureDeviceInfo> devices = CaptureDeviceManager.getDeviceList(null);

                                        for (CaptureDeviceInfo info : devices) { 

                                                     Format[] formats = info.getFormats();

                                                     for (Format format : formats)

Unknown macro: {                                                                   if (!(format instanceof RGBFormat)) continue;                                                                   RGBFormat rgb = (RGBFormat) format;                                                                   Dimension size = rgb.getSize();                                                                   if (size.width != width || size.height != height) continue;                                                                   if (rgb.getPixelStride() != 3) continue;                                                                   if (rgb.getBitsPerPixel() != 24) continue;                                                                   if ( rgb.getLineStride() != width*3 ) continue;                                                                   MediaLocator locator = info.getLocator();                                                                   DataSource source = Manager.createDataSource(locator);                                                                   source.connect();                                                                   System.out.println();                                                                   ((CaptureDevice)source).getFormatControls()[0].setFormat(rgb);                                                                   return Manager.createRealizedPlayer(source);                                                      }

                                        }

                           } catch (IOException e)

Unknown macro: {                                         e.printStackTrace();                            }

catch (NoPlayerException e)

Unknown macro: {                                        e.printStackTrace();                           }

catch (CannotRealizeException e)

catch (NoDataSourceException e)

Unknown macro: {                                        e.printStackTrace();                           }

                           return null;

             } 

             public static void main(String[] args) {

                           int[] values = new int[args.length];

                           for (int i = 0; i < values.length; i++)

Unknown macro: {                                         values[i] = Integer.parseInt(args[i]);                            }


                           WebcamBroadcaster wb;

                           if (values.length == 0)

Unknown macro: {                                         wb = new WebcamBroadcaster();                            }

else if (values.length == 1)

Unknown macro: {                                         wb = new WebcamBroadcaster(values[0]);                            }

else if (values.length == 2)

Unknown macro: {                                         wb = new WebcamBroadcaster(values[0], values[1]);                            }

else

Unknown macro: {                                         wb = new WebcamBroadcaster(values[0], values[1], values[2]);                            }


                           wb.start();

             } 

             public static final int DEFAULT_PORT = 5000;

             public static final int DEFAULT_WIDTH = 320;

             public static final int DEFAULT_HEIGHT = 240; 

             private final Object lock = new Object(); 

             private final int width;

             private final int height;

             private final int port; 

             private boolean running; 

             private Player player;

             private FrameGrabbingControl control;

             private boolean stopping;

             private Worker worker; 

             public WebcamBroadcaster(int width, int height, int port)

Unknown macro: {                            this.width = width;                            this.height = height;                            this.port = port;              }


             public WebcamBroadcaster(int width, int height)

Unknown macro: {                            this(width, height, DEFAULT_PORT);              }


             public WebcamBroadcaster(int port)

Unknown macro: {                            this(DEFAULT_WIDTH, DEFAULT_HEIGHT, port);              }


             public WebcamBroadcaster()

Unknown macro: {                            this(DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_PORT);              }


             public void start() {

                           synchronized (lock) {

                                        if (running) return;

                                        player = createPlayer(width, height);

                                        if (player == null)

Unknown macro: {                                                      System.err.println("Unable to find a suitable player");                                                      return;                                         }

                                        player.start();

                                        control = (FrameGrabbingControl) player.getControl("javax.media.control.FrameGrabbingControl");

                                        worker = new Worker();

                                        worker.start();

                                        running = true;

                           }

             } 

             public void stop() throws InterruptedException {

                           synchronized (lock) {

                                        if (!running) return;

                                        if (player != null)

Unknown macro: {                                                      control = null;                                                      player.stop();                                                      player = null;                                         }

                                        stopping = true;

                                        running = false;

                                        worker = null;

                           }

                           try

Unknown macro: {                                         worker.join();                            }

finally

Unknown macro: {                                         stopping = false;                            }

             } 

             private class Worker extends Thread { 

                           private final int[] data = new int[width*height]; 

                           @Override

                           public void run() {

                                        ServerSocket ss;

                                        try

Unknown macro: {                                                      ss = new ServerSocket(port);\                                         }

catch (IOException e)

Unknown macro: {                                                      e.printStackTrace();                                                      return;                                         }


                                        while(true) {

                                                     FrameGrabbingControl c;

                                                     synchronized (lock)

Unknown macro: {                                                                   if (stopping) break;                                                                   c = control;                                                      }

                                                     Socket socket = null;

                                                     try {

                                                                  socket = ss.accept(); 

                                                                  Buffer buffer = c.grabFrame();

                                                                  BufferToImage btoi = new BufferToImage((VideoFormat)buffer.getFormat());

                                                                  BufferedImage image = (BufferedImage) btoi.createImage(buffer); 

                                                                  if (image != null) {

                                                                                OutputStream out = socket.getOutputStream();

                                                                                if (RAW) {

                                                                                             image.getWritableTile(0, 0).getDataElements(0, 0, width, height, data);

                                                                                             image.releaseWritableTile(0, 0);

                                                                                             DataOutputStream dout = new DataOutputStream(new BufferedOutputStream(out));

                                                                                             for (int i = 0; i < data.length; i++)

Unknown macro: {                                                                                                           dout.writeInt(data[i]);                                                                                              }

                                                                                             dout.close();

                                                                                } else

Unknown macro: {                                                                                              ImageIO.write(image, "JPEG", out);                                                                                 }

                                                                  } 

                                                                  socket.close();

                                                                  socket = null;

                                                     } catch (IOException e)

Unknown macro: {                                                                   e.printStackTrace();                                                      }

finally {

                                                                  if (socket != null)

                                                                                try

Unknown macro: {                                                                                              socket.close();                                                                                 }

catch (IOException e)

Unknown macro: {                                                                                              -- ignore --                                                                                 }

                                                     } 

                                        } 

                                        try

Unknown macro: {                                                      ss.close();                                         }

catch (IOException e)

Unknown macro: {                                                      -- ignore --                                         }

                           } 

             } 


SDCARD image 표시 ANDROID

package com.ubsni.gallery;import android.app.Activity;import android.os.Bundle;import java.util.ArrayList;import android.provider.MediaStore;import android.content.Context;import android.content.Intent;import android.database.Cursor;import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.view.View;import android.view.ViewGroup;import android.view.animation.Animation;import android.widget.AdapterView;import android.widget.BaseAdapter;import android.widget.GridView;import android.widget.ImageView;import android.widget.AdapterView.OnItemClickListener;import com.ubsni.gallery.R;--* * Image list class. * @author UBSNI --public class gallery extends Activity {	--* Log tag for this project. --	private static final String TAG_SEMI = "gallery";	--* Context variable. --	private Context mContext;	--*	 * On create this class.	 * @param savedInstanceState : Bundle variable	 --	@Override    public final void onCreate(final Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.image_list);        mContext = this;        GridView gv = (GridView) findViewById(R.id.ImgGridView);        final ImageAdapter ia = new ImageAdapter(this);        gv.setAdapter(ia);        gv.setOnItemClickListener(new OnItemClickListener() {        	public void onItemClick(final AdapterView parent,        							final View v,        							final int position,        							final long id) {        		ia.callImageViewer(position);        	}        });	}	--*	 * Adapter class.	 --	public class ImageAdapter extends BaseAdapter {		--* image path. --		private String strImageData;		--* Geo data. --		private String strGeoData;		--* thumbs data list. --		private ArrayList<String> thumbsDataList;		--* thumbs id list. --		private ArrayList<String> thumbsIDList;		--*		 * Image adapder.		 * @param context : context variable		 --		public ImageAdapter(final Context context) {			mContext = context;			thumbsDataList = new ArrayList<String>();			thumbsIDList = new ArrayList<String>();			getThumbInfo(thumbsIDList, thumbsDataList);		}		--*		 * call image viewer.		 * @param selectedIndex : selected image index		 --		public final void callImageViewer(final int selectedIndex) {			Intent addUserInfo = getIntent();			Bundle addUser = addUserInfo.getExtras();			Intent intentImage = new Intent(mContext, galleryPopup.class);			String imgPath = getImageInfo(strImageData, strGeoData,										  thumbsIDList.get(selectedIndex));			intentImage.putExtra("PhotoPath", imgPath);			intentImage.putExtras(addUser);			startActivityForResult(intentImage, 1);		}		--*		 * Delete selected index.		 * @param nIndex : index		 * @return true		 --		public final boolean deleteSelected(final int nIndex) {			return true;		}		--*		 * Get thumbs id list.		 * @return thumbsIDList.size()		 --		public final int getCount() {			return thumbsIDList.size();		}		--*		 * Get Item.		 * @param position : item position		 * @return position		 --		public final Object getItem(final int position) {			return position;		}		--*		 * Get item id.		 * @param position : item id position		 * @return position		 --		public final long getItemId(final int position) {			return position;		}		--*		 * Get view.		 * @param position : position		 --		public View getView(int position, View convertView, ViewGroup parent) {			ImageView imageView;			int nSampleSize = 8;			if (convertView == null) {				imageView = new ImageView(mContext);				imageView.setLayoutParams(new GridView.LayoutParams(85, 85));				imageView.setAdjustViewBounds(false);				imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);				imageView.setPadding(8, 8, 8, 8);			} else {				imageView = (ImageView) convertView;			}			BitmapFactory.Options bo = new BitmapFactory.Options();			bo.inSampleSize = nSampleSize;			Bitmap bmp = BitmapFactory.decodeFile(thumbsDataList.get(position), bo);			Bitmap resized = Bitmap.createScaledBitmap(bmp, 85, 85, true);			imageView.setImageBitmap(resized);			return imageView;		}		 //Thumb 파일의 내용을 가져온다.		private void getThumbInfo(ArrayList<String> thumbsIDs, ArrayList<String> thumbsDatas) {			String[] proj = {MediaStore.Images.Media._ID,							 MediaStore.Images.Media.DATA,							 MediaStore.Images.Media.DISPLAY_NAME,							 MediaStore.Images.Media.SIZE							 };			Cursor imageCursor = managedQuery(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,					proj, null, null, null);			if (imageCursor != null && imageCursor.moveToFirst()) {				String title;				String thumbsID;				String thumbsImageID;				String thumbsData;				String data;				String imgSize;				int thumbsIDCol = imageCursor.getColumnIndex(MediaStore.Images.Media._ID);				int thumbsDataCol = imageCursor.getColumnIndex(MediaStore.Images.Media.DATA);				int thumbsImageIDCol = imageCursor.getColumnIndex(MediaStore.Images.Media.DISPLAY_NAME);				int thumbsSizeCol = imageCursor.getColumnIndex(MediaStore.Images.Media.SIZE);				int num = 0;				do {					thumbsID = imageCursor.getString(thumbsIDCol);					thumbsData = imageCursor.getString(thumbsDataCol);					thumbsImageID = imageCursor.getString(thumbsImageIDCol);					imgSize = imageCursor.getString(thumbsSizeCol);					num++;					if (thumbsImageID != null) {						thumbsIDs.add(thumbsID);						thumbsDatas.add(thumbsData);					}				} while (imageCursor.moveToNext());			}			imageCursor.close();			return;		}		//Image의 정보를 가져온다.		private String getImageInfo(String ImageData, String Location, String thumbID) {			String imageDataPath = null;			String[] proj = {MediaStore.Images.Media._ID,					 MediaStore.Images.Media.DATA,					 MediaStore.Images.Media.DISPLAY_NAME,					 MediaStore.Images.Media.SIZE};			Cursor imageCursor =				managedQuery(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,							 proj,							 "_ID='" + thumbID + "'",							 null,							 null);			if (imageCursor != null && imageCursor.moveToFirst()) {				if (imageCursor.getCount() > 0) {					int imgData = imageCursor.getColumnIndex(MediaStore.Images.Media.DATA);					imageDataPath = imageCursor.getString(imgData);				}			}			imageCursor.close();			return imageDataPath;		}	}}

XML animation ANDROID

<set>

자기 자신 또는 다른 애니메이션을 재귀적으로 보유할 수 있는 컨테이너. AnimationSet을 표현한다. 여러분이 원하는 만큼, 동일하거나 또는 다른 타입의 자식child 엘리먼트를 많이 포함할 수 있다. 다음의 애트리뷰트를 지원한다.shareInterpolator - 모든 인접한 자식child 엘리먼트 사이에서 같은 인터폴레이터interpolator를 공유하는지에 대한 여부.

<alpha>

페이딩fading 애니메이션. AlphaAnimation을 표현한다. 다음의 애트리뷰트를 지원한다.fromAlpha - 0.0 에서 1.0, 여기에서 0.0은 투명임.toAlpha - 0.0 에서 1.0, 여기에서 0.0은 투명임.

<scale>

크기를 변경하는 애니메이션. ScaleAnimation를 표현한다. 여러분은 pivotX와 pivotY를 지정함으로써 그것으로부터 바깥 쪽(또는 안 쪽)으로 커지는 이미지의 중심 지점(핀이 꼿힌 중심)을 지정할 수 있다. 예를 들어 만약 이것들이 0,0(왼쪽 상단 모서리)인 경우, 모든 증가는 아래와 우측으로 될 것이다. 스케일은 다음의 애트리뷰트를 지원한다.fromXScale - 시작하는 X 크기(여기에서 1.0은 어떤 변화도 없는 것임)toXScale - 끝나는 X 크기(여기에서 1.0이 어떤 변화도 없는 것임)fromYScale - 시작하는 Y 크기(여기에서 1.0은 어떤 변화도 없는 것임)toYScale - 끝나는 Y 크기(여기에서 1.0은 어떤 변화도 없는 것임)pivotX - 핀이 꽂힌 중심의 X 좌표.pivotY - 핀이 꽂힌 중심의 Y 좌표.

<translate>

수직/수평 움직임 애니메이션. TranslateAnimation을 표현한다. 뒤따르는 세 개의 포맷으로 된 어떤 애트리뷰트든 지원한다. "%"로 끝나는 -100에서 100까지 값은, 그것 자신에 상대적인 백분율을 가리킨다. "%p"로 끝나는 -100에서 100까지 값은, 자신의 부모parent에 상대적인 백분율을 가리킨다. 접미어가 없는 부동소수점은 절대 값을 가리킨다.fromXDelta - 시작하는 X 위치.toXDelta -끝나는 X 위치.fromYDelta - 시작하는 Y 위치.toYDelta - 끝나는 Y 위치.

<rotate>

회전 애니메이션. RotateAnimation을 표현한다. 다음의 애트리뷰트를 지원한다.fromDegrees - 회전을 시작하는 각도.toDegrees - 회전을 끝내는 각도.pivotX - 회전의 중심에 대한 픽셀 X 좌표, 여기에서 (0,0)은 왼쪽 상단 모서리.pivotY - 회전의 중심에 대한 픽셀 Y 좌표, 여기에서 (0,0)은 왼쪽 상단 모서리.

<interpolator tag>

여러분은 또한 R.styleable에서 정의된 임의의 interpolator 서브클래스 엘리먼트를 사용할 수 있다. 예제들은 <CycleInterpolator>, <EaseInInterpolator>, 그리고 <EaseOutInterpolator>를 포함한다. 이 오브젝트는 타임라인 상에서 시각적 액션이 얼마나 빠르게 일어나는가를 설명하는 속도 곡선을 정의한다(먼저 빠르게 그리고 나중에 느리게, 먼저 느리게 그리고 점차적으로 빠르게, 그리고 기타 등등).

-참고 자료 - http://www.kandroid.org/guide/topics/resources/available-resources.html


1 2 3 4 5 6 7 8 9 10 다음