public class MyLocalService extends Service {

   private LocalBinder mLocalBinder - new LocalBinder();

   public IBinder onBind(Intent intent){
     return mLocalBinder;
   }

   public void doLongRunningOperation(){
     //오랜 시간이 걸리는 작업을 위해 새 스레드를 시작
   }

   public class LocalBinder extends Binder {
     public MyLocalService getService(){
       return MyLocalService.this;
     }
   }
 }

 public class MainActivity extends Activity
         implements ServiceConnection, MyLocalService.Callback {
     private MyLocalService mService;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main_activity);
     }

     @Override
     protected void onResume() {
         super.onResume();
         Intent bindIntent = new Intent(this, MyLocalService.class);
         bindService(bindIntent, this, BIND_AUTO_CREATE);
     }

     @Override
     protected void onPause() {
         super.onPause();
         if (mService != null) {
             unbindService(this);
         }
     }

         @Override
         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
             mService =((MyLocalService.LocalBinder) iBinder).getService();

         }

         @Override
         public void onServiceDisconnected(ComponentName componentName) {
             mService = null;
         }
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         if (intent != null) { // We might receive a null intent since we start with START_NOT_STICKY
             String action = intent.getAction();


             if (ACTION_SHARE_PHOTO.equals(action)) {
                 // Build the notification to be shown
                 Notification.Builder builder = new Notification.Builder(this);
                 builder.setSmallIcon(R.drawable.ic_launcher);
                 builder.setContentTitle(getString(R.string.notification_title));
                 builder.setContentText(getString(R.string.notification_text));
                 Notification notification = builder.build();
                 // Start the service in the foreground
                 startForeground(NOTIFICATION_ID, notification);

                 // Upload the photo
                 String photoText = intent.getStringExtra(EXTRA_PHOTO_TEXT);
                 Bitmap photoBitmap = intent.getParcelableExtra(EXTRA_PHOTO_BITMAP);
                 uploadPhotoWithText(photoBitmap, photoText);
             }
         }
         return START_NOT_STICKY;
     }

 public class MyMusicPlayer extends Service implements MediaPlayer.OnCompletionListener {
     public static final String ACTION_ADD_TO_QUEUE = "com.aptl.services.ADD_TO_QUEUE";
     private ConcurrentLinkedQueue<Uri> mTrackQueue;
     private MediaPlayer mMediaPlayer;

     public IBinder onBind(Intent intent) {
         return null;
     }

     @Override
     public void onCreate() {
         super.onCreate();
         mTrackQueue = new ConcurrentLinkedQueue<Uri>();
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         String action = intent.getAction();
         if (ACTION_ADD_TO_QUEUE.equals(action)) {
             Uri trackUri = intent.getData();
             addTrackToQueue(trackUri);
         }
         return START_NOT_STICKY;
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         if(mMediaPlayer != null) {
             mMediaPlayer.release();
             mMediaPlayer = null;
         }
     }


//   Add track to end of queue if already playing,
//   otherwise create a new MediaPlayer and start playing.

     private void addTrackToQueue(Uri trackUri) {
         if(mMediaPlayer == null) {
             try {
                 mMediaPlayer = MediaPlayer.create(this, trackUri);
                 mMediaPlayer.setOnCompletionListener(this);
                 mMediaPlayer.prepare();
                 mMediaPlayer.start();
             } catch (IOException e) {
                 stopSelf();
             }
         } else {
             mTrackQueue.offer(trackUri);
         }
     }

     // Track completed, start playing next or stop service...
     @Override
     public void onCompletion(MediaPlayer mediaPlayer) {
         mediaPlayer.reset();
         Uri nextTrackUri = mTrackQueue.poll();
         if(nextTrackUri != null) {
             try {
                 mMediaPlayer.setDataSource(this, nextTrackUri);
                 mMediaPlayer.prepare();
                 mMediaPlayer.start();
             } catch (IOException e) {
                 stopSelf();
             }
         } else {
             stopSelf();
         }
     }
 }

    public class MyIntentService extends IntentService {
        private static final String NAME = "MyIntentService";
        public static final String ACTION_UPLOAD_PHOTO = "com.aptl.services.UPLOAD_PHOTO";
        public static final String EXTRA_PHOTO = "bitmapPhoto";
        public static final String ACTION_SEND_MESSAGE = "com.aptl.services.SEND_MESSAGE";
        public static final String EXTRA_MESSAGE = "messageText";
        public static final String EXTRA_RECIPIENT = "messageRecipient";

        public static final String BROADCAST_UPLOAD_COMPLETED = "com.aptl.services.UPLOAD_COMPLETED";

        public MyIntentService() {
            super(NAME);
            // We don't want intents redelivered in case we're shut down unexpectedly
            setIntentRedelivery(false);
        }

        /**
         * 이 메서드는 한 번에 한 인텐트씩 자체 스레드에서 실행.
         */
        @Override
        protected void onHandleIntent(Intent intent) {
            String action = intent.getAction();

            if(ACTION_SEND_MESSAGE.equals(action)) {
                String messageText = intent.getStringExtra(EXTRA_MESSAGE);
                String messageRecipient = intent.getStringExtra(EXTRA_RECIPIENT);
                sendMessage(messageRecipient, messageText);
            } else if(ACTION_UPLOAD_PHOTO.equals(action)) {
                Bitmap photo = intent.getParcelableExtra(EXTRA_PHOTO);
                uploadPhoto(photo);
            }
        }

        private void sendMessage(String messageRecipient, String messageText) {
            // TODO Make network call...
            //작업이 완료됐음을 브로드캐스트로 알림
        }

    private void uploadPhoto(Bitmap photo) {
        // TODO Make network call...
        ////작업이 완료됐음을 브로드캐스트로 알림
        sendBroadcast(new Intent(BROADCAST_UPLOAD_COMPLETED));
    }
  }

    public class MediaTranscoder extends Service {
        private static final int NOTIFICATION_ID = 1001;
        public static final String ACTION_TRANSCODE_MEDIA = "com.aptl.services.TRANSCODE_MEDIA";
        public static final String EXTRA_OUTPUT_TYPE = "outputType";
        private ExecutorService mExecutorService;
        private int mRunningJobs = 0;
        private final Object mLock = new Object();
        private boolean mIsForeground = false;

        public IBinder onBind(Intent intent) {
            return null;
        }

        @Override
        public void onCreate() {
            super.onCreate();
            mExecutorService = Executors.newCachedThreadPool();
        }

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            String action = intent.getAction();
            if(ACTION_TRANSCODE_MEDIA.equals(action)) {
                String outputType = intent.getStringExtra(EXTRA_OUTPUT_TYPE);

                // Start new job and increase the running job counter
                synchronized (mLock) {
                    TranscodeRunnable transcodeRunnable = new TranscodeRunnable(intent.getData(), outputType);
                    mExecutorService.execute(transcodeRunnable);
                    mRunningJobs++;
                    startForegroundIfNeeded();
                }
            }
            return START_NOT_STICKY;
        }

        @Override
        public void onDestroy() {
            super.onDestroy();
            mExecutorService.shutdownNow();
            synchronized (mLock) {
                mRunningJobs = 0;
                stopForegroundIfAllDone();
            }
        }

        public void startForegroundIfNeeded() {
            if(!mIsForeground) {
                Notification notification = buildNotification();
                startForeground(NOTIFICATION_ID, notification);
            }
        }

        private Notification buildNotification() {
            Notification notification = null;
            // TODO Build the notification here...
            return notification;
        }

        private void stopForegroundIfAllDone() {
            if(mRunningJobs == 0) {
                stopForeground(true);
                mIsForeground = false;
            }
        }

        private class TranscodeRunnable implements Runnable {
            private Uri mInData;
            private String mOutputType;

            private TranscodeRunnable(Uri inData, String outputType) {
                mInData = inData;
                mOutputType = outputType;
            }

            @Override
            public void run() {
                // TODO Perform transcoding here...

                // Decrease counter when we're done...
                synchronized (mLock) {
                    mRunningJobs--;
                    stopForegroundIfAllDone();
                }
            }
        }
    }

     public class MyLocalService extends Service {
         private static final int NOTIFICATION_ID = 1001;
         private LocalBinder mLocalBinder = new LocalBinder();
         private Callback mCallback;

         public IBinder onBind(Intent intent) {
             return mLocalBinder;
         }

         public void performLongRunningOperation(MyComplexDataObject dataObject) {
             new MyAsyncTask().execute(dataObject);
         }

         public void setCallback(Callback callback) {
             mCallback = callback;
         }

         public class LocalBinder extends Binder {
             public MyLocalService getService() {
                 return MyLocalService.this;
             }
         }

         public interface Callback {
             void onOperationProgress(int progress);
             void onOperationCompleted(MyComplexResult complexResult);
         }

         private final class MyAsyncTask extends AsyncTask<MyComplexDataObject, Integer, MyComplexResult> {

             @Override
             protected void onPreExecute() {
                 super.onPreExecute();
                 startForeground(NOTIFICATION_ID, buildNotification());
             }

             @Override
             protected void onProgressUpdate(Integer... values) {
                 if(mCallback != null && values.length > 0) {
                     for (Integer value : values) {
                         mCallback.onOperationProgress(value);
                     }
                 }
             }

             @Override
             protected MyComplexResult doInBackground(MyComplexDataObject... myComplexDataObjects) {
                 MyComplexResult complexResult = new MyComplexResult();
                 // Actual operation left out for brevity...
                 return complexResult;
             }

             @Override
             protected void onPostExecute(MyComplexResult myComplexResult) {
                 if(mCallback != null ) {
                     mCallback.onOperationCompleted(myComplexResult);
                 }
                 stopForeground(true);
             }

             @Override
             protected void onCancelled(MyComplexResult complexResult) {
                 super.onCancelled(complexResult);
                 stopForeground(true);
             }
         }

         private Notification buildNotification() {
             Notification notification = null;
             // Create a notification for the service..
             return notification;
         }
     }

    public class MainActivity extends Activity
            implements ServiceConnection, MyLocalService.Callback {
        private MyLocalService mService;

         // Called when the activity is first created.
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main_activity);
        }

        @Override
        protected void onResume() {
            super.onResume();
            Intent bindIntent = new Intent(this, MyLocalService.class);
            bindService(bindIntent, this, BIND_AUTO_CREATE);
        }

        @Override
        protected void onPause() {
            super.onPause();
            if (mService != null) {
                mService.setCallback(null); // Important to avoid memory leaks
                unbindService(this);
            }
        }

        public void onTriggerLongRunningOperation(View view) {
            if(mService != null) {
                mService.performLongRunningOperation(new MyComplexDataObject());
            }
        }

        @Override
        public void onOperationProgress(int progress) {
            // TODO Update user interface with progress..
        }

        @Override
        public void onOperationCompleted(MyComplexResult complexResult) {
            // TODO Show result to user...
        }

        @Override
        public void onServiceConnected(ComponentName componentName,
                                       IBinder iBinder) {
            mService = ((MyLocalService.LocalBinder) iBinder).getService();
            mService.setCallback(this);

            // Once we have a reference to the service, we can update the UI and
            // enable buttons that should otherwise be disabled.
            findViewById(R.id.trigger_operation_button).setEnabled(true);
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            // Disable the button as we are loosing the reference to the service.
            findViewById(R.id.trigger_operation_button).setEnabled(false);
            mService = null;
        }
    }