<?php // config/fcm.php

return [
    'server_key' => env('FCM_SERVER_KEY'),
    'sender_id' => env('FCM_SENDER_ID'),
    'server_send_url' => 'https://fcm.googleapis.com',
    'timeout' => 30, // in second
];

 1 <?php // app/Providers/FcmServiceProvider
 2 
 3 namespace App\Providers;
 4 
 5 use App\Services\EloquentFcmDeviceRepository;
 6 use App\Services\FcmDeviceRepository;
 7 use App\Services\FcmHandler;
 8 use GuzzleHttp\Client as GuzzleClient;
 9 use Illuminate\Contracts\Config\Repository as ConfigRepository;
10 use Illuminate\Contracts\Foundation\Application;
11 use Illuminate\Support\ServiceProvider;
12 use Psr\Log\LoggerInterface;
13 
14 class FcmServiceProvider extends ServiceProvider
15 {
16     public function register()
17     {
18         $this->bindFcmDeviceRepository();
19         $this->bindFcmHandler();
20     }
21 
22     private function bindFcmDeviceRepository()
23     {
24         $this->app->bind(FcmDeviceRepository::class, EloquentFcmDeviceRepository::class);
25     }
26 
27     private function bindFcmHandler()
28     {
29         $this->app->bind(FcmHandler::class, function (Application $app) {
30             $config = $app->make(ConfigRepository::class)->get('fcm');
31 
32             $httpClient = new GuzzleClient([
33                 'base_uri' => $config['server_send_url'],
34                 'headers' => [
35                     'Authorization' => "key={$config['server_key']}",
36                     'Content-Type' => 'application/json',
37                     'project_id' => $config['sender_id'],
38                 ],
39                 'timeout' => $config['timeout'],
40             ]);
41             $deviceRepo = $app->make(FcmDeviceRepository::class);
42             $logger = $app->make(LoggerInterface::class);
43 
44             return new FcmHandler($httpClient, $deviceRepo, $logger);
45         });
46     }
47 }

 1 <?php // app/Services/FcmDeviceRepository.php
 2 
 3 namespace App\Services;
 4 
 5 interface FcmDeviceRepository
 6 {
 7     public function updateFcmDevice(string $oldId, string $newId);
 8     public function deleteFcmDevice(string $deprecatedId);
 9 }

 1 <?php // app/Services/EloquentFcmDeviceRepository.php
 2 
 3 namespace App\Services;
 4 
 5 use App\Device;
 6 use DB;
 7 
 8 class EloquentFcmDeviceRepository implements FcmDeviceRepository
 9 {
10     public function updateFcmDevice(string $oldId, string $newId)
11     {
12         $device = Device::where('push_service_id', $oldId)->first();
13         if ($device === null) {
14             return;
15         }
16 
17         $device->push_service_id = $newId;
18 
19         DB::transaction(function () use ($device) {
20             $device->save();
21         });
22     }
23 
24     public function deleteFcmDevice(string $deprecatedId)
25     {
26         $device = Device::where('push_service_id', $deprecatedId)->first();
27         if ($device === null) {
28             return;
29         }
30 
31         DB::transaction(function () use ($device) {
32             $device->delete();
33         });
34     }
35 }

  1 <?php // app/Services/FcmHandler.php
  2 
  3 namespace App\Services;
  4 
  5 use Exception;
  6 use GuzzleHttp\Client as GuzzleClient;
  7 use GuzzleHttp\Psr7\Request;
  8 use Psr\Log\LoggerInterface;
  9 
 10 class FcmHandler
 11 {
 12     const MAX_TOKEN_PER_REQUEST = 1000;
 13     const API_ENDPOINT = 'fcm/send';
 14 
 15     private $httpClient;
 16     private $deviceRepo;
 17     private $logger;
 18 
 19     private $receivers;
 20     private $message;
 21     private $retryIntervalInUs = 100000; // 100ms
 22     private $maxRetryCount = 3;
 23     private $retriedCount = 0;
 24 
 25     public function __construct(
 26         GuzzleClient $httpClient,
 27         FcmDeviceRepository $deviceRepo,
 28         LoggerInterface $logger
 29     ) {
 30         $this->httpClient = $httpClient;
 31         $this->deviceRepo = $deviceRepo;
 32         $this->logger = $logger;
 33     }

 35     public function sendMessage()
 36     {
 37         if (count(array_filter($this->receivers)) === 0) {
 38             $this->logProgress('푸쉬 알림을 전송을 건너 뜁니다: 수신자가 없습니다.');
 39             return;
 40         }
 41 
 42         if ($this->isInitialRequest()) {
 43             $this->logProgress('푸쉬 알림을 전송합니다.', [
 44                 'receivers' => $this->receivers,
 45                 'message' => $this->message,
 46             ], 'debug');
 47         }
 48 
 49         try {
 50             if (count($this->receivers) > self::MAX_TOKEN_PER_REQUEST) {
 51                 $response = null;
 52                 foreach (array_chunk($this->receivers, self::MAX_TOKEN_PER_REQUEST) as $chunk) {
 53                     $responsePartial = $this->_sendMessage($chunk);
 54                     if (!$response) {
 55                         $response = $responsePartial;
 56                     } else {
 57                         $response->merge($responsePartial);
 58                     }
 59 
 60                     usleep(1);
 61                 }
 62             } else {
 63                 $response = $this->_sendMessage($this->receivers);
 64             }
 65 
 66             $this->updatePushServiceIdsIfAny($response);
 67             $this->handleDeliveryFailureIfAny($response);
 68 
 69             $this->logProgress("푸쉬 알림을 전송했습니다.", [
 70                 'receiver' =>$this->receivers,
 71             ]);
 72         } catch (Exception $e) {
 73             $this->logProgress("푸쉬 알림을 전송하지 못헸습니다: {$e->getMessage()}", [
 74                 'receiver' => $this->receivers,
 75             ], 'error');
 76             throw $e;
 77         }
 78     }

 80     public function setReceivers(array $receivers)
 81     {
 82         $this->receivers = $receivers;
 83     }
 84 
 85     public function setMessage(array $message)
 86     {
 87         $this->message = $message;
 88     }

 90     private function _sendMessage(array $tokens)
 91     {
 92         $request = $this->getRequest($tokens);
 93         $guzzleResponse = $this->httpClient->send($request);
 94 
 95         return new DownstreamResponse($guzzleResponse, $tokens);
 96     }
 97 
 98     private function getRequest(array $tokens)
 99     {
100         // 'to' for single receiver,
101         // 'registration_ids' for multiple receivers
102         $httpBody = \GuzzleHttp\json_encode([
103             'registration_ids' => $tokens,
104             'notification' => null,
105             'data' => $this->message,
106         ]);
107 
108         return new Request('POST', self::API_ENDPOINT, [], $httpBody);
109     }

111     private function updatePushServiceIdsIfAny(DownstreamResponse $response)
112     {
113         if ($response->numberModification() <= 0) {
114             return;
115         }
116 
117         /**
118          * @var array $pushServiceIdsToModify {
119          *     @var string $oldPushServiceId => string $newPushServiceId
120          * }
121          */
122         $pushServiceIdsToModify = $response->tokensToModify();
123 
124         // 메시지는 성공적으로 전달되었습니다.
125         // 단말기 공장 초기화 등의 이유로 구글 Fcm 서버에 등록된 registration_id가 바뀌었습니다.
126         $this->logProgress('구글 서버와 push_service_id 를 동기화합니다.', [
127             'push_service_id_to_modify' => $pushServiceIdsToModify
128         ]);
129 
130         foreach ($pushServiceIdsToModify as $oldPushServiceId => $newPushServiceId) {
131             $this->deviceRepo->updateFcmDevice($oldPushServiceId, $newPushServiceId);
132         }
133     }

135     private function handleDeliveryFailureIfAny(DownstreamResponse $response)
136     {
137         if ($response->numberFailure() <= 0) {
138             return;
139         }
140 
141         $pushServiceIdsToDelete = $response->tokensToDelete();
142         if (! empty($pushServiceIdsToDelete)) {
143             // 해당 registration_id를 가진 단말기가 구글 Fcm 서비스에 등록되어 있지 않습니다.
144             $this->logProgress('사용불가한 push_service_id 를 삭제합니다.', [
145                 'push_service_ids_to_delete' => $pushServiceIdsToDelete
146             ]);
147 
148             foreach ($pushServiceIdsToDelete as $pushServiceIdToDelete) {
149                 $this->deviceRepo->deleteFcmDevice($pushServiceIdToDelete);
150             }
151         }
152 
153         $pushServiceIdsToRetry = $response->tokensToRetry();
154         if (! empty($pushServiceIdsToRetry)) {
155             if ($this->isFinalRetry()) {
156                 // 재시도 했지만 메시지 전송에 실패했습니다.
157                 throw new Exception();
158             }
159 
160             // 최대 3회, 1회는 기본값, 다음 루프는 2회, 3회까지 실행됨.
161             $this->retriedCount = $this->retriedCount + 1;
162             // (최초 1회 200밀리초 뒤 실행, 2회 400밀리초 뒤, 3회 800밀리초 뒤) -> 프로세스가 총 1.4초동안 실행됨.
163             // @see https://firebase.google.com/docs/cloud-messaging/http-server-ref?hl=ko#error-codes
164             $this->retryIntervalInUs = $this->retryIntervalInUs * 2;
165 
166             usleep($this->retryIntervalInUs);
167 
168             $this->logProgress("{$this->getOrdinalRetryCount()} 재전송 시도합니다.", [
169                 'retried_count' => $this->retriedCount,
170                 'push_service_ids_to_retry' => $pushServiceIdsToRetry,
171             ]);
172 
173             $this->receivers = $pushServiceIdsToRetry;
174             $this->sendMessage();
175         }
176     }

178     private function isInitialRequest()
179     {
180         return $this->retriedCount === 0;
181     }
182 
183     private function isFinalRetry()
184     {
185         return $this->retriedCount === $this->maxRetryCount;
186     }
187 
188     private function getOrdinalRetryCount()
189     {
190         switch ($this->retriedCount) {
191             case 1:  return '첫번째';
192             case 2:  return '두번째';
193             case 3:  return '세번째';
194             default: return '';
195         }
196     }
197 
198     private function logProgress(string $message, $context = [], string $level = 'debug')
199     {
200         $this->logger->log($level, "[FcmHandler] {$message}", $context);
201     }
202 }

<?php // routes/api.php

Route::post('fcm_test', function (App\Services\FcmHandler $fcmHandler) {
    $user = App\User::find(1);
    $fcmHandler->setReceivers($user->getPushServiceIds());
    $fcmHandler->setMessage([
        'message' => 'Hello Fcm',
    ]);
    $fcmHandler->sendMessage();
    
    return new Illuminate\Http\JsonResponse(null, 200);
});

<?php // app/User.php

class User extends Authenticatable
{
    // ...

    public function getPushServiceIds()
    {
        return $this->devices->pluck('push_service_id')->all();
    }
}