그림 원각, 축소 등 효과 도구류

public class ImageUtil {

        public static InputStream getRequest(String path) throws Exception {
                URL url = new URL(path);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(5000);
                if (conn.getResponseCode() == 200){
                        return conn.getInputStream();
                }
                return null;
        }

        public static byte[] readInputStream(InputStream inStream) throws Exception {
                ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
                byte[] buffer = new byte[4096];
                int len = 0;
                while ((len = inStream.read(buffer)) != -1) {
                        outSteam.write(buffer, 0, len);
                }
                outSteam.close();
                inStream.close();
                return outSteam.toByteArray();
        }
        
        public static Drawable loadImageFromUrl(String url){
        URL m;
        InputStream i = null;
        try {
            m = new URL(url);
            i = (InputStream) m.getContent();
        } catch (MalformedURLException e1) {
            e1.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        Drawable d = Drawable.createFromStream(i, "src");
        return d;
    }
        
        public static Drawable getDrawableFromUrl(String url) throws Exception{
                 return Drawable.createFromStream(getRequest(url),null);
        }
        
        public static Bitmap getBitmapFromUrl(String url) throws Exception{
                byte[] bytes = getBytesFromUrl(url);
                return byteToBitmap(bytes);
        }
        
        public static Bitmap getRoundBitmapFromUrl(String url,int pixels) throws Exception{
                byte[] bytes = getBytesFromUrl(url);
                Bitmap bitmap = byteToBitmap(bytes);
                return toRoundCorner(bitmap, pixels);
        } 
        
        public static Drawable geRoundDrawableFromUrl(String url,int pixels) throws Exception{
                byte[] bytes = getBytesFromUrl(url);
                BitmapDrawable bitmapDrawable = (BitmapDrawable)byteToDrawable(bytes);
                return toRoundCorner(bitmapDrawable, pixels);
        } 
        
        public static byte[] getBytesFromUrl(String url) throws Exception{
                 return readInputStream(getRequest(url));
        }
        
        public static Bitmap byteToBitmap(byte[] byteArray){
                if(byteArray.length!=0){ 
            return BitmapFactory.decodeByteArray(byteArray, 0, byteArray.length); 
        } 
        else { 
            return null; 
        }  
        }
        
        public static Drawable byteToDrawable(byte[] byteArray){
                ByteArrayInputStream ins = new ByteArrayInputStream(byteArray);
                return Drawable.createFromStream(ins, null);
        }
        
        public static byte[] Bitmap2Bytes(Bitmap bm){ 
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
                return baos.toByteArray();
        }
        
        public static Bitmap drawableToBitmap(Drawable drawable) {

                Bitmap bitmap = Bitmap
                                .createBitmap(
                                                drawable.getIntrinsicWidth(),
                                                drawable.getIntrinsicHeight(),
                                                drawable.getOpacity() != PixelFormat.OPAQUE ? Bitmap.Config.ARGB_8888
                                                                : Bitmap.Config.RGB_565);
                Canvas canvas = new Canvas(bitmap);
                drawable.setBounds(0, 0, drawable.getIntrinsicWidth(),
                                drawable.getIntrinsicHeight());
                drawable.draw(canvas);
                return bitmap;
        }
        
                 /**
              *     ,      
              * @param bmpOriginal      
             * @return       
             */
            public static Bitmap toGrayscale(Bitmap bmpOriginal) {
                int width, height;
                height = bmpOriginal.getHeight();
                width = bmpOriginal.getWidth();    
        
                Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
                Canvas c = new Canvas(bmpGrayscale);
                Paint paint = new Paint();
                ColorMatrix cm = new ColorMatrix();
                cm.setSaturation(0);
                ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
                paint.setColorFilter(f);
                c.drawBitmap(bmpOriginal, 0, 0, paint);
                return bmpGrayscale;
            }
            
            
            /**
             *        
             * @param bmpOriginal   
             * @param pixels     
             * @return       
             */
            public static Bitmap toGrayscale(Bitmap bmpOriginal, int pixels) {
                return toRoundCorner(toGrayscale(bmpOriginal), pixels);
            }
            
            /**
             *        
             * @param bitmap        
             * @param pixels      
             * @return     
             */
            public static Bitmap toRoundCorner(Bitmap bitmap, int pixels) {
        
                Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);
                Canvas canvas = new Canvas(output);
        
                final int color = 0xff424242;
                final Paint paint = new Paint();
                final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
                final RectF rectF = new RectF(rect);
                final float roundPx = pixels;
        
                paint.setAntiAlias(true);
                canvas.drawARGB(0, 0, 0, 0);
                paint.setColor(color);
                canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
        
                paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
                canvas.drawBitmap(bitmap, rect, rect, paint);
        
                return output;
            }
        
            
           /**
             *        BitampDrawable
             * @param bitmapDrawable 
             * @param pixels 
             * @return
             */
            public static BitmapDrawable toRoundCorner(BitmapDrawable bitmapDrawable, int pixels) {
                Bitmap bitmap = bitmapDrawable.getBitmap();
                bitmapDrawable = new BitmapDrawable(toRoundCorner(bitmap, pixels));
                return bitmapDrawable;
            }
        
}

시간 도구

public class TimeUtil {
        
        public static String converTime(long timestamp){
                long currentSeconds = System.currentTimeMillis()/1000;
                long timeGap = currentSeconds-timestamp;//         
                String timeStr = null;
                if(timeGap>24*60*60){//1   
                        timeStr = timeGap/(24*60*60)+"  ";
                }else if(timeGap>60*60){//1  -24  
                        timeStr = timeGap/(60*60)+"   ";
                }else if(timeGap>60){//1  -59  
                        timeStr = timeGap/60+"   ";
                }else{//1  -59  
                        timeStr = "  ";
                }
                return timeStr;
        }
        
        public static String getStandardTime(long timestamp){
                SimpleDateFormat sdf = new SimpleDateFormat("MM dd  HH:mm");
                Date date = new Date(timestamp*1000);
                sdf.format(date);
                return sdf.format(date);
        }
}