Belajar NativePHP - Proses Background & Persistent Mode

#Pendahuluan

Setelah di episode 10 kita mengelola database SQLite offline dengan Eloquent, pada episode ini kita masuk ke proses background & persistent mode: bagaimana PHP runtime di NativePHP bisa tetap hidup, menjalankan tugas di latar belakang, dan menjadwalkan tugas periodik — sambil memahami batasan platform yang berbeda antara iOS dan Android.

Di aplikasi web, PHP process hidup hanya selama satu request. Di NativePHP, PHP runtime persistent — ia tetap hidup selama aplikasi terbuka, memungkinkan polling, listening events, dan background processing yang berkelanjutan.

#Persistent Mode

#Apa itu Persistent Mode?

Dalam mode normal (web), PHP process berakhir setelah response dikirim. Di NativePHP, PHP runtime berjalan dalam persistent mode: process tidak dimatikan, tetap berjalan di belakang, dan bisa menjalankan tugas kapan saja.

Konfigurasi persistent mode

<?php
 
return [
    'persistent' => [
        'enabled' => true,
        'max_memory_mb' => 256,  // batas memori untuk PHP runtime
        'idle_timeout_sec' => 300, // timeout jika tidak ada aktivitas
    ],
];

Persistent mode memungkinkan:

Connection pooling: koneksi database tetap terbuka, tidak perlu buka-tutup setiap request.
In-memory cache: data yang sering diakses bisa di-cache di memori PHP.
Long-running listeners: PHP bisa mendengarkan event dari native shell secara real-time.

#Background Task

#Queue di Perangkat

Laravel queue bisa berjalan langsung di perangkat menggunakan database driver (SQLite):

app/Jobs/SyncNotes.php

<?php
 
namespace App\Jobs;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use App\Repositories\NoteRepository;
 
class SyncNotes implements ShouldQueue
{
    use Dispatchable, Queueable;
 
    public function handle(NoteRepository $notes): void
    {
        $unsynced = $notes->getUnsynced();
 
        foreach ($unsynced as $note) {
            try {
                \Http::post('https://api.myapp.com/sync/note', [
                    'id' => $note->id,
                    'title' => $note->title,
                    'content' => $note->content,
                ]);
 
                $note->markSynced();
            } catch (\Exception $e) {
                // Log error, retry nanti
                \Log::error("Sync failed for note {$note->id}: {$e->getMessage()}");
            }
        }
    }
}

#Menjalankan Queue Worker

Jalankan queue worker di perangkat

php artisan queue:work --sleep=30 --tries=3

Queue worker ini berjalan di dalam aplikasi — tidak perlu server terpisah. --sleep=30 berarti worker mengecek queue setiap 30 detik, menghemat CPU dan baterai.

#Scheduling Ringan

Task Scheduler Laravel bisa dijalankan di perangkat untuk tugas periodik:

app/Console/Kernel.php

<?php
 
namespace App\Console;
 
use Illuminate\Console\Scheduling\Schedule;
use App\Jobs\SyncNotes;
use App\Jobs\CleanupOldLogs;
 
class Kernel
{
    protected function schedule(Schedule $schedule): void
    {
        // Sync notes setiap 15 menit
        $schedule->job(new SyncNotes)->everyFifteenMinutes();
 
        // Cleanup log lama setiap malam
        $schedule->job(new CleanupOldLogs)->daily();
 
        // Cek update dari server setiap jam
        $schedule->call(function () {
            $latestVersion = \Http::get('https://api.myapp.com/app/version')
                ->json('version');
 
            if ($latestVersion !== config('app.version')) {
                \Native\Laravel\Facades\Notification::local()
                    ->title('Update Tersedia')
                    ->body('Versi baru tersedia. Perbarui aplikasi.')
                    ->send();
            }
        })->hourly();
    }
}

Jalankan scheduler

php artisan schedule:work

#Batasan Platform: iOS vs Android

#iOS: Background Execution Terbatas

iOS sangat agresif dalam menghentikan aplikasi di background untuk menghemat baterai. NativePHP berjalan dengan batasan:

Mode	Durasi	Kapan
Foreground	Tanpa batas	Aplikasi aktif di layar
Background fetch	~30 detik	iOS memberikan waktu terbatas
Silent push	~30 detik	Push notification tanpa suara/alert
Background task	~30 detik	Request dari app saat masuk background

iOS tidak mengizinkan PHP runtime tetap hidup di background selama berjam-jam. Untuk tugas panjang, gunakan background fetch atau silent push dari server.

#Android: Background Lebih Fleksibel

Android memberikan lebih banyak fleksibilitas:

Mode	Durasi	Kapan
Foreground	Tanpa batas	Aplikasi aktif
Foreground service	Tanpa batas	Service dengan notifikasi visible
Background service	~10 menit	Background task biasa
WorkManager	Bervariasi	Scheduled task yang dijamin berjalan

Warning

Android 12+ membatasi background service baru. Gunakan WorkManager atau foreground service untuk task yang membutuhkan waktu lama. Foreground service harus menampilkan notifikasi visible yang memberitahu user bahwa aplikasi sedang bekerja.

#Praktik: Job Sinkronisasi Periodik

Job yang bertahan antar sesi

<?php
 
namespace App\Jobs;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use App\Repositories\NoteRepository;
use Native\Laravel\Facades\Biometric;
 
class PeriodicSync implements ShouldQueue
{
    use Queueable;
 
    public function handle(NoteRepository $notes): void
    {
        // Hanya sync jika user sudah login (biometric authenticated)
        if (!session()->has('biometric_auth')) {
            return;
        }
 
        $pending = $notes->getPendingCount();
 
        if ($pending > 0) {
            $notes->getUnsynced()->each(function ($note) {
                \Http::post('https://api.myapp.com/sync', [
                    'id' => $note->id,
                    'data' => $note->toArray(),
                ]);
                $note->markSynced();
            });
        }
    }
}

#Penutup

Inti yang harus dibawa pulang:

Persistent mode menjaga PHP runtime hidup — memungkinkan connection pooling, in-memory cache, dan long-running listeners.
Queue worker berjalan di perangkat menggunakan SQLite driver.
Task Scheduler menjalankan tugas periodik: sync, cleanup, update check.
iOS: background execution terbatas (~30 detik); gunakan silent push untuk tugas panjang.
Android: lebih fleksibel; gunakan WorkManager atau foreground service.

Di episode 12 selanjutnya, kita akan membahas v4 SuperNative: Blade → SwiftUI/Jetpack Compose — revolusi rendering UI tanpa WebView, mapping komponen ke native elements, dan konversi layar WebView-based menjadi native UI murni. Sampai jumpa di episode 12!