حقن تطبيقات المنصة

An interface defines a capability, but something must hand shared code the real platform implementation. That wiring is dependency injection.

Shared logic should not construct platform classes itself. Instead it receives the implementation from outside, keeping it decoupled and testable.

The simplest approach is a constructor parameter. Pass the capability in, and the class never knows which platform built it.

On Android, the app module creates the real actual and passes it down when it builds the shared object.

On iOS, Swift constructs the framework's DeviceInfo and injects it the same way, so shared code stays identical across platforms.

For many dependencies, a DI library like Koin declares each capability once in a shared module and resolves it on demand.

In Koin you bind the interface type to the platform implementation, so callers ask for DeviceInfo and get the right concrete one.

Anywhere in shared code you can pull a dependency from the graph by its type, no manual construction required.

Because everything is injected, a test simply provides a fake implementation. No platform, emulator, or device is involved. ✅

Keep injection at each app's entry point. That single setup spot decides which actuals run, while shared code stays blissfully unaware.

If a DI library feels heavy, a plain factory function works too. It builds the platform object in one place and hands it to shared code.

Think about why shared code receives its dependencies.

You learned to inject platform implementations via the constructor or Koin, binding interfaces to actuals so shared code stays clean and testable. 🎉