앤 드 리 오 드 는 어떻게 자신의 폴 링 프레임 워 크 를 구축 합 니까?

안 드 로 이 드 애플 리 케 이 션 은 서버 에 데 이 터 를 요청 할 때 가 많 습 니 다.서버 데이터 가 업데이트 되면 인터페이스 변 화 를 알 립 니 다.Android 에서 가장 자주 사용 하 는 빨 간 점 은 일반적으로 폴 링 을 사용 합 니 다.빨 간 점 은 데이터 가 업데이트 되 었 을 때 사용자 에 게 신속하게 알 리 기 위해 서 입 니 다.예 를 들 어 친구 권 이 업데이트 되면 사용자 의 친구 권 이 업 데 이 트 될 때 빨 간 점 이 나타 납 니 다.바로 모 바 일 단 을 통 해 끊임없이 서버 에 친구 권 의 업데이트 상 태 를 조회 하 는 것 입 니 다.
관련 지식
폴 링 구 조 를 실현 할 때 주로 다음 과 같은 두 가지 유형 으로 가 야 한다.폴 링 구 조 를 결합 하여 이 세 가지 유형 에 대해 설명 하고 응용 에서 분석 하면 더욱 깊이 이해 할 수 있다.
1.IntentService IntentService 는 특수 한 Service 로 Service 를 계승 하고 추상 적 인 클래스 이 므 로 하위 클래스 를 만들어 야 사용 할 수 있 습 니 다.IntentService 는 배경 에서 시간 이 걸 리 는 작업 을 수행 하 는 데 사용 할 수 있 습 니 다.작업 이 실 행 된 후에 자동 으로 정지 합 니 다.IntentService 의 우선 순 위 는 일반 스 레 드 보다 높 고 우선 순위 가 높 은 배경 작업 을 수행 하 는 데 적합 합 니 다.
2.PendingIntent PendingIntent 는 지연 되 는 intent 로 특정한 사건 이 완 료 된 후에 특정한 Action 을 수행 하 는 데 사 용 됩 니 다.PendingIntent 는 Intent 및 Context 를 포함 하고 있 기 때문에 Intent 소속 프로그램 이 끝나 도 PendingIntent 는 유효 하 며 다른 프로그램 에서 사용 할 수 있 습 니 다.PendingIntent 는 보통 매개 변수 로 인 스 턴 스 를 전달 합 니 다.이 인 스 턴 스 가 특정한 작업 을 완성 한 후에 PendingIntent 의 Action 을 자동 으로 실행 할 수도 있 고 PendingIntent 의 send 함 수 를 통 해 수 동 으로 실행 할 수도 있 으 며 send 함수 에 OnFinished 를 설정 하여 send 가 성공 한 후에 실 행 된 동작 을 표시 할 수도 있 습 니 다.
폴 링 프레임 워 크 실현
폴 링 을 실현 하려 면 Handler 의 looper 체 제 를 참고 할 수 있 습 니 다.다음 그림 은 메시지 대기 열 을 유지 하고 순환 적 으로 메시지 대기 열 에서 메 시 지 를 꺼 내 실행 할 수 있 습 니 다.폴 링 프레임 워 크 는 정기 적 으로 메시지 대기 열 에 메 시 지 를 추가 한 다음 에 순환 적 으로 메시지 대기 열 에서 메 시 지 를 꺼 낼 수 있 습 니 다.

Looper 를 스스로 실현 할 수 있 지만 IntentService 에는 Looper 와 HandlerThread 가 포함 되 어 있 습 니 다.따라서 폴 링 프레임 워 크 에 서 는 IntentService 를 순환 프레임 워 크 로 사용 합 니 다.IntentService 인 터 페 이 스 를 계승 하여 메시지 접근 서버 를 처리 합 니 다.
폴 링 서 비 스 는 폴 링 할 때마다 서버 인터페이스 데 이 터 를 요청 하 는 데 사 용 됩 니 다.

public class PollingService extends IntentService {
	public static final String ACTION_CHECK_CIRCLE_UPDATE="ACTION_CHECK_CIRCLE_UPDATE";	
	public static final long DEFAULT_MIN_POLLING_INTERVAL = 60000;//      1  
 public PollingService() {
  super("PollingService");
 }
	
 @Override
 protected void onHandleIntent(Intent intent) {
  if (intent == null)
   return;
  final String action = intent.getAction();
  if (ACTION_CHECK_Circle_UPDATE.equals(action)) {
   CheckCircleOfFriendsUpdate();//                 
  }
 }
}

폴 링 서 비 스 는 폴 링 메 시 지 를 받 은 후onHandleIntent(Intent intent)에서 Intent 가 가지 고 있 는 action 에 따라 서버 의 서로 다른 인터페이스 에 접근 하여 데 이 터 를 얻 는 데 사 용 됩 니 다.
폴 링 유 틸 리 티 는 폴 링 유 틸 리 티 의 startPollingService 를 사용 하여 action 과 context 에 따라 PendingIntent 를 생 성하 고 PendingIntent 를 폴 링 Scheduler 에 맡 기 는 데 사 용 됩 니 다.PollingScheduler 는 스 레 드 탱크 제어 클래스 입 니 다.

public class PollingUtil {
 /**
  *       
  */
 public static void startPollingService(final Context context, String action) {
   //      Service Intent
   Intent intent = new Intent(context, PollingService.class);
   intent.setAction(action);
   PendingIntent pendingIntent = PendingIntent.getService(context, 0,
     intent, PendingIntent.FLAG_UPDATE_CURRENT);
   PollingScheduler.getInstance().addScheduleTask(pendingIntent, 0, PollingService.DEFAULT_MIN_POLLING_INTERVAL);
  }
 }
 /**
  *       
  *
  * @param context
  */
 public static void stopPollingServices(Context context, String action) {
   PollingScheduler.getInstance().clearScheduleTasks();
  }
 }

PollingScheduler 는 정기 적 으로 IntentService 의 Looper 에 메 시 지 를 추가 합 니 다.PollingScheduler 에 단일 라인 풀 을 생 성 합 니 다.addScheduleTask 에서 정기 적 으로 pendingIntent.send()를 실행 합 니 다.그 중에서 PendingIntent 는PendingIntent pendingIntent = PendingIntent.getService(context, 0,intent, PendingIntent.FLAG_UPDATE_CURRENT);에서 생 성 되 었 습 니 다.pendingIntent.send()함 수 는 Service.startService()를 호출 하여 서 비 스 를 시작 합 니 다.

public class PollingScheduler {
 private static PollingScheduler sInstance;
 private ScheduledExecutorService mScheduler;

 private PollingScheduler() {
  mScheduler = Executors.newSingleThreadScheduledExecutor();
 }

 public static synchronized PollingScheduler getInstance() {
  if (sInstance == null) {
   sInstance = new PollingScheduler();
  }
  if (sInstance.mScheduler.isShutdown()) {
   sInstance.mScheduler = Executors.newSingleThreadScheduledExecutor();
  }
  return sInstance;
 }
	
 public void addScheduleTask(final PendingIntent pendingIntent, long initialDelay, long period) {
  Runnable command = new Runnable() {
   @Override
   public void run() {
    try {
     pendingIntent.send();
    } catch (PendingIntent.CanceledException e) {
     e.printStackTrace();
    }
   }
  };
  mScheduler.scheduleAtFixedRate(command, initialDelay, period, TimeUnit.MILLISECONDS);
 }

 public void clearScheduleTasks() {
  mScheduler.shutdownNow();
 }
}

코드 분석
먼저 아 날로 그 간 의 관 계 를 다음 과 같이 제시 합 니 다.
 
PollingService 는 IntentService 를 계승 하고 PollingUtil 의 startPollingService 방법 에서Intent intent = new Intent(context, PollingService.class);과 PendingIntent 를 PollingService 와 연결 시 키 고 PendingIntent 를 정시 에 실행 되 는 스 레 드 탱크 에 가입 하여 PollingScheduler 에서 사용pendingIntent.send();PendingIntent 는 PollingService 와 연결 되 어 있 기 때문에 pendingIntent.send()를 실행 할 때 PollingIntent Servide 의 onStart()방법 을 호출 합 니 다.onStart()방법 은 IntentService 의 방법 입 니 다.코드 는 다음 과 같 습 니 다.

 @Override
 public void onStart(@Nullable Intent intent, int startId) {
  Message msg = mServiceHandler.obtainMessage();
  msg.arg1 = startId;
  msg.obj = intent;
  mServiceHandler.sendMessage(msg);
 }

onstart()중 하나mServiceHandler.sendMessage(msg);가 있 습 니 다.mServiceHandler 의 생 성 위 치 를 찾 습 니 다.

 @Override
 public void onCreate() {
  super.onCreate();
  HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
  thread.start();

  mServiceLooper = thread.getLooper();
  mServiceHandler = new ServiceHandler(mServiceLooper);
 }

IntentService 의 onCreate 방법 에서 Handler Thread,mServiceLooper,mServiceHandler 를 생 성 했 습 니 다.그 중에서 mServiceHandler.sendmessage(msg)의 msg 는 모두 mServiceLooper 에 넣 고 실행 할 때 mServiceLooper 에서 꺼 내 서 실행 합 니 다.그 중에서 ServiceHandler 의 코드 는 다음 과 같 습 니 다.

 private final class ServiceHandler extends Handler {
  public ServiceHandler(Looper looper) {
   super(looper);
  }

  @Override
  public void handleMessage(Message msg) {
   onHandleIntent((Intent)msg.obj);
   stopSelf(msg.arg1);
  }
 }

handleMessage(Message msg)에서 onHandleIntent((Intent)msg.obj)를 호출 합 니 다.방법,즉 폴 링 서비스 에 다시 쓰 는 on Handle Intent 방법 입 니 다.따라서 저 희 는 addScheduleTask 에서 pending.send()방법 을 계속 실행 하고 IntentService 의 onStart 방법 중의 mServiceHandler.sendmessage(msg)를 계속 호출 합 니 다.메시지 큐 에 메 시 지 를 계속 보 내 고 onHandle Intent 에서 메 시 지 를 처리 합 니 다.이렇게 폴 링 프레임 워 크 가 완성 되 었 다.
총결산
본 논문 의 폴 링 프레임 워 크 는 IntentService 중의 handler 와 Looper 체 제 를 이용 하여 순환 적 인 처리 정 보 를 실현 하 였 으 며,IntentService 는 서비스의 특성 을 가지 기 때문에 배경 폴 링 으로 서버 데 이 터 를 방문 하 는 데 특히 적합 하 다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.