LINE Bot SDK for PHP

The KitchenSink sample is organized into several key components:

• Entry Point: public/index.php serves as the application entry point.
• Core Logic: src/LINEBot/KitchenSink/Route.php contains the main application logic interacting with the LINE Messaging API.
• Event Handlers: src/LINEBot/KitchenSink/EventHandler contains the specific logic for handling different types of LINE Messaging API events.
• Multimedia Storage: Files are temporarily stored in ./public/static/tmpdir/.

To process user actions (messages, images, etc.) sent by LINE's server, follow these steps:

1. Receive the webhook request from LINE's server.
2. Parse the request payload using EventRequestParser#parseEventRequest($body, $channelSecret, $signature).
3. Iterate through the parsed events and implement your bot's logic.

To interact with the LINE Messaging API, you need to instantiate a GuzzleHttp\ Client, a LINE\\Clients\\MessagingApi\\Configuration object with your channel access token, and a LINE\\Clients\\MessagingApi\\Api\\MessagingApiApi instance.

use GuzzleHttp\Client;
use LINE\Clients\MessagingApi\Configuration;
use LINE\Clients\MessagingApi\Api\MessagingApiApi;

$client = new Client();
$config = new Configuration();
$config->setAccessToken('<channel access token>');
$messagingApi = new MessagingApiApi(
    client: $client,
    config: $config,
);

Install the SDK using Composer. Ensure you have PHP 8.2 or later installed.

composer require linecorp/line-bot-sdk

If you need to inspect the HTTP status code or response headers for a successful request, use the methods ending in WithHttpInfo (e.g., replyMessageWithHttpInfo). These methods return an array containing three elements: [$body, $statusCode, $headers]. You can then access specific headers like x-line-request-id from the $headers array.

[$body, $statusCode, $headers] = $messagingApi->replyMessageWithHttpInfo($request);

$requestId = $headers['x-line-request-id'][0];

By default, the SDK uses environment variables for configuration. To customize settings such as the HTTP client configuration (e.g., adding custom headers), you must publish the configuration file to config/line-bot.php using the following command:

php artisan vendor:publish --provider="LINE\Laravel\LINEBotServiceProvider" --tag=config

The published config/line-bot.php file allows you to manage the following keys:

• channel_access_token: The LINE Channel Access Token.
• channel_id: The LINE Channel ID.
• channel_secret: The LINE Channel Secret.
• client.config.headers: An array of HTTP headers to include in requests.

The SDK supports Laravel via facades.

1. Add LINE_BOT_CHANNEL_ACCESS_TOKEN to your .env file.
2. Use the \LINEMessagingApi facade for calls.

To customize the configuration (e.g., adding custom headers), publish the config file:

$ php artisan vendor:publish --provider="LINE\Laravel\LINEBotServiceProvider" --tag=config

Then modify config/line-bot.php:

return [
    'channel_access_token' => env('LINE_BOT_CHANNEL_ACCESS_TOKEN'),
    'channel_id' => env('LINE_BOT_CHANNEL_ID'),
    'channel_secret' => env('LINE_BOT_CHANNEL_SECRET'),
    'client' => [
        'config' => [
          'headers' => ['X-Foo' => 'Bar'],
        ],
    ],
];

The KitchenSink sample is a full-stack implementation of the LINE Messaging API using the Slim framework. To set it up locally, follow these steps:

1. Install Composer if you haven't already.
2. Install the project dependencies using Composer.
3. Configure your bot credentials in src/LINEBot/KitchenSink/Setting.php.
4. Run the application using the provided shell script.

Note: The application uses a temporary directory for multimedia files which is cleared upon shutdown.

$ curl -sS https://getcomposer.org/installer | php # Install composer.phar
$ ./composer.phar install
$ $EDITOR ./src/LINEBot/KitchenSink/Setting.php # <= edit your bot information
$ ./run.sh 8080

To process user actions (messages, images, locations, etc.) sent by LINE's server, you must receive the webhook request and parse the body using the EventRequestParser.

Follow these steps:

1. Receive the webhook request from LINE.
2. Use EventRequestParser::parseEventRequest() to validate the signature and parse the request body.
3. Iterate through the parsed events using getEvents() to handle each specific event type.

use LINE//Parser/EventRequestParser;

$parsedEvents = EventRequestParser::parseEventRequest(
    $body,           // The raw request body
    $channelSecret,  // Your LINE Channel Secret
    $signature,      // The X-Line-Signature header value
);

foreach ($parsedEvents->getEvents() as $event) {
    // Handle event
}

To interact with the Messaging API, you must instantiate a MessagingApiApi object. This requires a GuzzleHttp ClientInterface implementation (such as GuzzleHttp Client) and a Configuration object containing your channel access token.

$client = new \GuzzleHttp\Client();
$config = new \LINE\Clients\MessagingApi\Configuration();
$config->setAccessToken('<channel access token>');
$messagingApi = new \LINE\Clients\MessagingApi\Api\MessagingApiApi(
  client: $client,
  config: $config,
);

When an API call fails, it throws a \LINE\Clients\MessagingApi\ApiException. You can extract the HTTP status code, the error response body, and the x-line-request-id from the exception's response headers.

try {
    $profile = $messagingApi->getProfile("invalid-userId");
} catch (\LINE\Clients\MessagingApi\ApiException $e) {
    $headers = $e->getResponseHeaders();
    $lineRequestId = isset($headers['x-line-request-id']) ? $headers['x-line-request-id'][0] : 'Not Available';
    $httpStatusCode = $e->getCode();
    $errorMessage = $e->getResponseBody();

    // Use $lineRequestId, $httpStatusCode, and $errorMessage
}