Service

서비스는 백그라운드에서 작업을 하기 위해서 사용한다.

- 쓰레드를 사용시 뒤로가기 누르면 쓰레드는 계속 진행되고, 다시돌아오면 잊어버림, 중지안되고 계속 진행됨..

- 쓰레드는 액티비티안에서 통제 

-서비스는 액티비티 밖에서도 사용하면 좋을듯

 

안드로이드의 서비스는 총 세종류

• 포그라운드 - 전면에 올라와있음, 알림창 띄워짐 사용자와 상호작용 ex)음악앱 / UnboundService
• 백그라운드 - 사용자에게 보이지 않는 ex)다운로드  / UnboundService
• 바인드  - 사용자와 상호작용할때, 액티비와 <-> 서비스가 바인딩됨 / 마치 클라이언트 - 서버와 같이 동작한다.

https://forest71.tistory.com/185

Android Immortal Service (죽지않는 서비스) 구현하기

 

 

https://youtu.be/rxK_M9VfX2o  

서비스?  화면 없이 백그라운드에서 실행되는 하나의 단위를 서비스(Service)라고 부릅니다.

서비스는 startService 메소드를 호출하면 시작됩니다.

서비스도 onCreate와 onDestroy 메소드가 있어서 메모리에 만들어질 때와 메모리에서 없어질 때 자동으로 호출됩니다.

서비스는 항상 실행되어 있을 수 있도록 비정상 종료되는 상황이 벌어지더라도 시스템에 의해 자동으로 재시작됩니다.

 

포그라운드 서비스	백그라운드 서비스
서비스가 전면에 항상 올라와 있는것, 절대 종료가 되지 않는다.	보이지 X, 뒤에서 실행되고 있는 상태로 시스템이 리소스가 부족한경우 OS에서 임의로 중단이 가능하다.
보이는 화면이 실행되고 있는 상태 (ex: 알림창에 띄워지면서, 실행, 상호작용 가능) 채팅창을 꺼도 채팅이오면 알림창이 나타남
알림을 함께 제공해야한다.  notification

 서비스가 시작되면 이를 시작한 구성요소와 독립적인 수명주기를 가지게 된다.

• 서비스 (Service)
• startService
• onStartCommand - 인텐트 객체는 여기서 받아서 처리 

https://developer.android.com/guide/components/services?hl=ko 

service	동시에 여러 작업이 가능, 멀티쓰레딩 but 기기 성능 저하할수있음 종료 되지 않는다. 오래걸리는 작업시 쓰레드를 사용해야한다. 백그라운드에서 동작하지만 메인스레드에 포함
IntentService	1.순차적으로 실행된다.  2.메인쓰레드가 아닌 새로운 쓰레드에서 실행된다.   3. 모든 동작이 수행되면 자동으로 종료된다.   오래 걸리지만 메인스레드와 관련이 없는 작업을 할때 주로 사용한다. 메인스레드와 관련된 작업을 해야 메인스레드 Handler나 Boradcast intent를 이용해야 한다.자동으로 종료된다.
bindService	액티비티에 서비스 객체를 생성해주기 때문에, 정보를 주고 받을 수 있다. 서비스 <->액티비티 바인딩된 서비스는  클라이언트 - 서버 인터페이스를 제공하여 구성요소가 서비스와 상호작용하게된다. 바인딩이 해제되면, 해당 서비스는 소멸된다.
forgroundService	서비스가 항상전면에 올라와 있는것, 알림을 함께 제공한다.  보이는화면이 실행되고 있는상태이다. 절대 종료되지 않는다.

****서비스는 메인 쓰레드에서 실행된다.

**** 눈에 보이지 않는 곳에서 쓰레드를 차지하고 있다. 쓰레드를 생성해야한다.

서비스와 스레드 간의 선택

서비스는 그저 백그라운드에서 실행될 수 있는 구성 요소일 뿐입니다. 이는 사용자가 애플리케이션과 상호작용하지 않아도 관계없이 해당됩니다. 그러므로 필요한 경우에만 서비스를 사용해야 합니다.

사용자가 애플리케이션과 상호작용하는 동안 기본 스레드 밖에서 작업을 수행해야 하는 경우, 새 스레드를 생성해야 합니다.. 예를 들어 액티비티가 실행되는 중에만 음악을 재생하고자 하는 경우, onCreate() 안에 스레드를 생성하고 이를 onStart()에서 실행하기 시작한 다음, onStop()에서 중단하면 됩니다. 또한 기존의 Thread 클래스 대신 AsyncTask 또는 HandlerThread를 사용하는 방안도 고려해보세요. 스레드에 관한 자세한 내용은 프로세스 및 스레딩 문서를 참조하세요.

서비스를 사용하는 경우 기본적으로 애플리케이션의 기본 스레드에서 계속 실행되므로 서비스가 집약적이거나 차단 작업을 수행하는 경우 여전히 서비스 내에 새 스레드를 생성해야 한다는 점을 명심하세요.

 

https://hijjang2.tistory.com/460?category=856483 

[Android] 서비스 2가지 방법- Service와 IntentService의 차이점

 

오준석의 생존코딩

https://youtu.be/IBm9D0KRJOk  

https://youtu.be/ZFP_axw4ge4  

 

부스트코스

https://www.boostcourse.org/mo316/lecture/259035

안드로이드 앱 프로그래밍

서비스 개요  |  Android 개발자  |  Android Developers

 

BindService - 바인드 묶다, 제본하다라는 뜻을 가지고 있다.

바인드 서비스는 서비스와 액티비티를 연결하고, 상호작용을 할때 사용한다.

 

구성요소가 bindService()를 호출하여 해당 서비스에 바인딩되면, 서비스가 바인딩된다.

바인딩된 서비스는  클라이언트 - 서버 인터페이스를 제공하여 구성요소가 서비스와 상호작용하게된다.

이로서 결과를 받을 수도 있고, 여러프로세스에 걸쳐 프로세스간 통신으로 수행할 수도 있다.

이 모든 것에서 바인딩이 해제되면, 해당 서비스는 소멸된다. 연결된 액티비티가 사라지면 서비스도 소멸된다.

하나의 서비스에 다수의 액티비티 연결이 가능

서비스는 마치 클라이언트-서버 와 같이 동작한다. 서비스가 서버역할을 하는 것이다. 

액티비티는 서비스에 요청을 할수 있고, 서비스로부터 어떠한 결과를 받을 수 있다.

사용X

 onStartCommand()는 구성 요소가 서비스를 시작하게 함.

onBind()는 바인드를 허용한다.

 

https://codechacha.com/ko/remoteservice-messenger/

안드로이드 - Messenger를 이용하여 Remote Service 구현하기

 MainActivity

package com.example.myapplication.Chat_test;

import androidx.appcompat.app.AppCompatActivity;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.example.myapplication.R;

import javax.security.auth.callback.CallbackHandler;


public class MainActivity extends AppCompatActivity {

    private final String TAG = "MainActivity";

    // 액티비티는 멤버변수로 두개의 Messenger 객체를 갖고 있다.

    // 서비스로부터 전달받는 객체 - IBinder로 만들어진 메신저객체를 받음
    private Messenger mServiceCallback = null;
    // 서비스로 전달해주는 객체
    // Messenger객체가 이벤트를 CallbackHandler에 던진다.(서비스로 전달해주는 객체)
    private Messenger mClientCallback = new Messenger(new CallbackHandler());

    private Button btnAddValue;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test3);

        Button btnAddValue = (Button)findViewById(R.id.btn_add_value);
        btnAddValue.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 서비스로부터 전달받는 객체 IBinder로 만들어진 메신저객체를 받음 <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< 받음
                if (mServiceCallback != null) {
                    // 서비스에 값을 추가하는 요청을 한다.
                    Message msg = Message.obtain(
                            null, RemoteService.MSG_ADD_VALUE);
                    msg.arg1 = 10;
                    try {
                        // 서비스로 부터 받아온 데이터
                        mServiceCallback.send(msg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    Log.e(TAG, "Send MSG_ADD_VALUE를 서비스로 보냄 // Send MSG_ADD_VALUE message to Service");
                }
            }
        });

        Log.e(TAG, "서비스와 연결시도 Trying to connect to service");
        Intent intent = new Intent(getApplicationContext(), RemoteService.class);
        // 서비스를 바인드한다.연결 객체,
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    // ServiceConnection을 정의하고, bindService를 통해 Service에 bind한다.
    // binding이 되면, serviceConnection으로 IBinder 객체가 전달되고 그것으로 Messenger객체를 만들 수 있다.
    private ServiceConnection mConnection = new ServiceConnection()
    {
        @Override
        // onServiceConnected 서비스에게 전달해주는 곳
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e(TAG, "onServiceConnected 온서비스커넥트");
            mServiceCallback = new Messenger(service);

            // 서비스와 연결한다.
            Message connect_msg = Message.obtain( null, RemoteService.MSG_CLIENT_CONNECT);
            connect_msg.replyTo = mClientCallback;
            try {
                // 서비스로 전달해주는 객체, 메시지를 서비스로 전달한다.
                mServiceCallback.send(connect_msg);
                Log.e(TAG, "MSG_CLIENT_CONNECT message를 서비스로 보냄 !!Send MSG_CLIENT_CONNECT message to Service");
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG, "연결 해제, onServiceDisconnected");
            mServiceCallback = null;
        }
    };

    // Messenger객체가 이벤트를 CallbackHandler에 던진다.(서비스로 전달해주는 객체) 서비스로 보냄 >>>>>>>>>>>>>>>>>>보냄
    // 여기서 보낸다.
    private class CallbackHandler extends Handler
    {
        @Override
        public void handleMessage(Message msg) { // 메신저 객체를 받아서,콜백 리스트에
            switch (msg.what) {
                case RemoteService.MSG_ADDED_VALUE:
                    Log.e(TAG, "서비스에게 받은 메시지 값: Recevied MSG_ADDED_VALUE message from service ~ value :" + msg.arg1);
                    break;


            }
        }
    }
}

 

RemoteService

package com.example.myapplication.Chat_test;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

import org.jetbrains.annotations.Nullable;

import java.util.ArrayList;

/**
 * Service를 상속,멤버변수로 Messenger객체를 저장하는 mClientCallbacks을 가지고 있다.
 */
public class RemoteService extends Service {
    private final String TAG = "RemoteService";
    public static final int MSG_CLIENT_CONNECT = 1;
    public static final int MSG_CLIENT_DISCONNECT = 2;
    public static final int MSG_ADD_VALUE = 3;
    public static final int MSG_ADDED_VALUE = 4;

    private ArrayList<Messenger> mClientCallbacks = new ArrayList<Messenger>();
    // Messenger가 MSG_CLIENT_CONNECT이벤트를 CallbackHandler로 던져준다.

    final Messenger mMessenger = new Messenger(new CallbackHandler());
    int mValue = 0;

    @Nullable
    @Override
    // mMessenger는 액티비티가 서비스에 이벤트를 전달할때 사용하는 객체
    // 액티비티가 서비스에 바인딩할때, 서비스는 mMessenger 객체의 IBinder를 전달해준다.
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        super.onStartCommand(intent, flags, startId);
        return START_STICKY;
    }

    @Override
    public void onDestroy(){
        super.onDestroy();
    }

    // 액티비티가 서비스로 전달한 이벤트들은 CallbackHandler 내부에서 처리가 됩니다. // 액티비티에서 받아온 인텐드를 처리하는 부분
    // 핸들러에 이벤트를 추가해야한다.
    // 동일한 앱에서 액티비티와 서비스가 다른 프로세스에서 실행되게 만들려면, 매니페스트에서 remote로 동작하도록 설정해줘야한다.<<<<<<<<<<<<<<<<액티비티에서 받음
    private class CallbackHandler  extends Handler {
        @Override
        public void handleMessage( Message msg ){
            switch( msg.what ){
                case MSG_CLIENT_CONNECT:
                    Log.e(TAG, "Received MSG_CLIENT_CONNECT message from client");
                    mClientCallbacks.add(msg.replyTo);
                    break;
                case MSG_CLIENT_DISCONNECT:
                    Log.e(TAG, "Received MSG_CLIENT_DISCONNECT message from client");
                    mClientCallbacks.remove(msg.replyTo);
                    break;
                case MSG_ADD_VALUE:
                    Log.e(TAG, "클라이언트에게 MSG_ADD_VALUE를 받음 Received message from client: MSG_ADD_VALUE");
                    mValue += msg.arg1;
                    for (int i = mClientCallbacks.size() - 1; i >= 0; i--) {
                        try{
                            Log.e(TAG, "클라이언트에게 보냄 MSG_ADDED_VALUE message를 ->Send MSG_ADDED_VALUE message to client");
                            Message added_msg = Message.obtain(
                                    null, RemoteService.MSG_ADDED_VALUE);
                            added_msg.arg1 = mValue;
                            mClientCallbacks.get(i).send(added_msg);
                        }
                        catch( RemoteException e){
                            mClientCallbacks.remove( i );
                        }
                    }
                    break;
            }
        }
    }
}

https://bitsoul.tistory.com/149

안드로이드 서비스 바인딩 예제 (Bound Service)

바인딩된 서비스는 bindService()를 호출하여 애플리케이션 구성 요소를 서비스에 바인딩하고 오래 유지되는 연결을 설정하는 것입니다. 일반적으로는 startService()를 호출하더라도 구성 요소가 서비스를 시작하도록 허용하지 않습니다.

액티비티와 애플리케이션의 다른 구성 요소에서 서비스와 상호작용하기를 원하는 경우 바인딩된 서비스를 생성해야 합니다. 아니면 애플리케이션의 기능 몇 가지를 프로세스 간 통신(IPC)을 통해 다른 애플리케이션에 노출하고자 하는 경우에도 좋습니다.

바인딩된 서비스를 생성하려면 onBind() 콜백 메서드를 구현하여 서비스와의 통신을 위한 인터페이스를 정의하는 IBinder를 반환하도록 해야 합니다. 그러면 다른 애플리케이션 구성 요소가 bindService()를 호출하여 해당 인터페이스를 검색하고, 서비스에 있는 메서드를 호출하기 시작할 수 있습니다. 서비스는 자신에게 바인딩된 애플리케이션 구성 요소에 도움이 되기 위해서만 존재하는 것이므로, 서비스에 바인딩된 구성 요소가 없으면 시스템이 이를 소멸시킵니다. 바인딩된 서비스는 서비스를 onStartCommand()를 통해 시작했을 때와 같은 방식으로 중단하지 않아도 됩니다.

 

바인딩된 서비스를 생성하려면 클라이언트가 서비스와 통신할 수 있는 방법을 나타내는 인터페이스를 정의해야 합니다. 서비스와 클라이언트 사이에서 쓰이는 이 인터페이스는 반드시 IBinder의 구현이어야 하며 이를 서비스가 onBind() 콜백 메서드에서 반환해야 합니다. 클라이언트가 IBinder를 수신하면 해당 인터페이스를 통해 서비스와 상호작용을 시작할 수 있습니다.

여러 클라이언트가 서비스에 한꺼번에 바인딩될 수 있습니다. 클라이언트가 서비스와의 상호작용을 완료하면 이는 unbindService()를 호출하여 바인딩을 해제합니다. 서비스에 바인딩된 클라이언트가 하나도 없으면 시스템이 해당 서비스를 소멸시킵니다.

 

 

어떻게 진행할지 동영상을 미리 보겠습니다.  https://bitsoul.tistory.com/149 예제 출처 

 

서비스 시작 버튼을 누르기전에, 서비스로부터 데이터 확인 하기 버튼을 누르면 -> 데이터를 확인할수 없다는 토스트가 생성

서비스 시작 버튼을 누르고, 서비스로부터 데이터 확인 하기 버튼을 누르면 -> 임의의 숫자데이터가 담긴 토스트 생성 

 

 

진행순서

1. 매니페스트에 서비스를 등록한다.

2.액티비티를 준비한다. xml

3. 서비스를 만든다.

4.액티비티에서 서비스를 시작하고, 서비스로 부터 데이터를 전달받는다.

 

- 메니페스트에 서비스를 등록합니다.

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".Main2Activity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
    <service android:name="MyService"></service>
</application>

 

- 액티비티 xml 를 작성합니다.

서비스시작 버튼, 종료버튼, 바인드 서비스로 부터 데이터를 받아오는 버튼 3개를 생성합니다.

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
>

    <Button
        android:id="@+id/button1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/textView1"
        android:layout_alignParentLeft="true"
        android:layout_marginLeft="153dp"
        android:layout_marginTop="45dp"
        android:text="서비스시작" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="34dp"
        android:text="서비스로 부터  데이터 전달 받기"
        android:textAppearance="?android:attr/textAppearanceLarge" />

    <Button
        android:id="@+id/button2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/button1"
        android:layout_below="@+id/button1"
        android:layout_marginTop="15dp"
        android:text="서비스종료" />

    <Button
        android:id="@+id/button3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/button2"
        android:layout_alignLeft="@+id/button2"
        android:layout_marginLeft="-61dp"
        android:layout_marginTop="27dp"
        android:text="서비스로부터 데이터 확인하기" />

</RelativeLayout>

 

 

Myservice.java - 서비스 클래스를 만듭니다.

외부로 데이터를 전달하려면 바인더를 사용해야합니다.

IBinder는 액티비티에서 bindService()를 실행하면 호출이 됩니다. 리턴한 IBinder객체는 서비스와 클라이언트 사이의 인터페이스를 정의하고, 서비스 객체를 리턴해줍니다. 클라이언트가 IBinder를 받으면 이 인터페이스를 통해 주고 받는 것이 가능해집니다.

package com.example.myapplication.Chat;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

import java.util.Random;

public class MyService extends Service {
    // 외부로 데이터를 전달하려면 바인더 사용

    // Binder 객체는 IBinder 인터페이스 상속구현 객체입니다
    //public class Binder extends Object implements IBinder

    IBinder mBinder = new MyBinder();

    class MyBinder extends Binder {
        MyService getService() { // 서비스 객체를 리턴
            return MyService.this;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        // 액티비티에서 bindService() 를 실행하면 호출됨
        // 리턴한 IBinder 객체는 서비스와 클라이언트 사이의 인터페이스 정의한다
        return mBinder; // 서비스 객체를 리턴
    }

    int getRan() { // 임의 랜덤값을 리턴하는 메서드
        return new Random().nextInt();
    }
    @Override
    public void onCreate() {
        super.onCreate();
    }
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

 

Main2Activity 메인액티비티에서 서비스를 실행하고, 데이터를 받아와 토스트를 띄웁니다.

서비스 시작하기 버튼을 눌러야만 서비스가 시작되며, 이버튼을 누르기전에는 서비스가 시작되지 않기 때문에, 데이터를 전달 받을 수 없습니다. 서비스 시작하기 버튼을 누르고 나서야 바인드 서비스로 부터 데이터를 전달 받을 수 있습니다.

package com.example.myapplication.Chat;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import androidx.appcompat.app.AppCompatActivity;

import com.example.myapplication.R;

public class Main2Activity extends AppCompatActivity {
    MyService ms; // 서비스 객체
    boolean isService = false; // 서비스 중인 확인용

    ServiceConnection conn = new ServiceConnection() {
        public void onServiceConnected(ComponentName name,
                                       IBinder service) {
// 서비스와 연결되었을 때 호출되는 메서드
// 서비스 객체를 전역변수로 저장
            MyService.MyBinder mb = (MyService.MyBinder) service;
            ms = mb.getService(); // 서비스가 제공하는 메소드 호출하여
// 서비스쪽 객체를 전달받을수 있음
            isService = true;// 서비스가 실행중이면 true
        }
        public void onServiceDisconnected(ComponentName name) {
// 서비스와 연결이 끊겼을 때 호출되는 메서드
            isService = false;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main6);
// 데이터를 전달할 수 있는 서비스 사용하기
// 1. 다음 Service (*.java)를 작성한다
// 2. Service 를 등록한다 AndroidManifest.xml
// 3. Service 를 시작한다

        Button b1 = (Button) findViewById(R.id.button1);// 서비스시작 버튼
        Button b2 = (Button) findViewById(R.id.button2);// 서비스 종료 버튼
        Button b3 = (Button) findViewById(R.id.button3);// 데이터받기 버튼

        b1.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) { // 서비스 시작
                Intent intent = new Intent(
                        Main2Activity.this, // 현재 화면
                        MyService.class); // 다음넘어갈 컴퍼넌트

                bindService(intent, // intent 객체
                        conn, // 서비스와 연결에 대한 정의
                        Context.BIND_AUTO_CREATE);
            }
        });
        b2.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) { // 서비스 종료

                unbindService(conn); // 서비스 종료
            }
        });
        b3.setOnClickListener(new View.OnClickListener() {
            public void onClick(View v) {//서비스데이터확인
                if (!isService) { // 서비스가 실행중이아니라면 
                    Toast.makeText(getApplicationContext(),
                            "서비스중이 아닙니다, 데이터받을수 없음",
                            Toast.LENGTH_LONG).show();
                    return;
                }
                int num = ms.getRan();// 서비스쪽 메소드로 값 전달 받아 호출받음
                Toast.makeText(getApplicationContext(),
                        "받아온 데이터 : " + num,
                        Toast.LENGTH_LONG).show();
            }
        });
    } // end of onCreate
} // end of class

---

 

서비스 이용해 배경음악 넣기

Android에서 Service 로 Background 에서 음악 플레이 하기