Vehicle Manager with Php Backend – Android (Kotlin)

Introduction

The Vehicle Manager is a powerful tool for managing vehicles, which is a crucial aspect of many industries such as transportation, logistics, and more. The Vehicle Manager allows you to track and manage vehicles in real-time, making it easier to optimize routes, reduce costs, and improve overall efficiency.

In this tutorial, we will guide you on how to use the Vehicle Manager with a PHP backend and an Android app built using Kotlin. We will cover the basics of setting up the backend, creating the Android app, and integrating the Vehicle Manager API.

Setting up the PHP Backend

Before we start building the Android app, we need to set up the PHP backend. We will use a simple PHP script to create a RESTful API that will interact with the Vehicle Manager.

1. Create a new PHP file called vehicle_manager.php and add the following code:

   
   <?php

// Configuration $db_host = 'localhost'; $db_username = 'root'; $db_password = ''; $db_name = 'vehicle_manager';

// Connect to the database $conn = new mysqli($db_host, $db_username, $db_password, $db_name);

// Check connection if ($conn->connect_error) { die("Connection failed: ". $conn->connect_error); }

// Function to get all vehicles function getVehicles() { $sql = "SELECT * FROM vehicles"; $result = $conn->query($sql); $vehicles = array(); if ($result->num_rows > 0) { while($row = $result->fetch_assoc()) { $vehicles[] = $row; } } return $vehicles; }

// Function to add a new vehicle function addVehicle($vehicle_data) { $sql = "INSERT INTO vehicles (plate_number, make, model, year) VALUES (?,?,?,?)"; $stmt = $conn->prepare($sql); $stmt->bind_param("sssi", $vehicle_data['plate_number'], $vehicle_data['make'], $vehicle_data['model'], $vehicle_data['year']); $stmt->execute(); $stmt->close(); }

// Function to update a vehicle function updateVehicle($vehicle_id, $vehicle_data) { $sql = "UPDATE vehicles SET plate_number =?, make =?, model =?, year =? WHERE id =?"; $stmt = $conn->prepare($sql); $stmt->bind_param("sssi", $vehicle_data['plate_number'], $vehicle_data['make'], $vehicle_data['model'], $vehicle_data['year'], $vehicle_id); $stmt->execute(); $stmt->close(); }

// Function to delete a vehicle function deleteVehicle($vehicle_id) { $sql = "DELETE FROM vehicles WHERE id =?"; $stmt = $conn->prepare($sql); $stmt->bind_param("i", $vehicle_id); $stmt->execute(); $stmt->close(); }

// API endpoints $app->get('/vehicles', function() { $vehicles = getVehicles(); echo json_encode($vehicles); });

$app->post('/vehicles', function($request) { $vehicle_data = $request->getJsonBody(); addVehicle($vehicle_data); echo json_encode(array('message' => 'Vehicle added successfully')); });

$app->put('/vehicles/{id}', function($request, $id) { $vehicle_data = $request->getJsonBody(); updateVehicle($id, $vehicle_data); echo json_encode(array('message' => 'Vehicle updated successfully')); });

$app->delete('/vehicles/{id}', function($request, $id) { deleteVehicle($id); echo json_encode(array('message' => 'Vehicle deleted successfully')); });

?>

This PHP script creates a RESTful API with four endpoints:

* `/vehicles`: Returns a list of all vehicles
* `/vehicles`: Adds a new vehicle
* `/vehicles/{id}`: Updates a vehicle
* `/vehicles/{id}`: Deletes a vehicle

**Creating the Android App**

Now that we have set up the PHP backend, let's create the Android app using Kotlin.

1. Create a new Android project in Android Studio and name it `VehicleManager`.
2. In the `build.gradle` file, add the following dependencies:
```groovy
dependencies {
    implementation 'com.android.volley:volley:1.1.0'
    implementation 'com.google.code.gson:gson:2.8.6'
}

These dependencies are required for making HTTP requests and parsing JSON data.

1. Create a new Kotlin class called VehicleManagerAPI:

   
   import android.content.Context
   import android.os.Bundle
   import android.util.Log
   import com.android.volley.RequestQueue
   import com.android.volley.Response
   import com.android.volley.toolbox.JsonArrayRequest
   import com.google.gson.Gson

class VehicleManagerAPI(private val context: Context) { private val requestQueue: RequestQueue private val gson: Gson

init {
    requestQueue = Volley.newRequestQueue(context)
    gson = Gson()
}

fun getVehicles(completion: (List<Vehicle>) -> Unit) {
    val url = "http://localhost:8000/vehicles"
    val request = JsonArrayRequest(url, Response.Listener { response ->
        val vehicles = gson.fromJson(response.toString(), ArrayList<Vehicle>::class.java)
        completion(vehicles)
    }, Response.ErrorListener { error ->
        Log.e("VehicleManagerAPI", "Error: $error")
    })
    requestQueue.add(request)
}

fun addVehicle(vehicle: Vehicle, completion: (Boolean) -> Unit) {
    val url = "http://localhost:8000/vehicles"
    val jsonBody = gson.toJson(vehicle)
    val request = JsonArrayRequest(url, jsonBody, Response.Listener { response ->
        completion(true)
    }, Response.ErrorListener { error ->
        Log.e("VehicleManagerAPI", "Error: $error")
        completion(false)
    })
    requestQueue.add(request)
}

fun updateVehicle(vehicle: Vehicle, completion: (Boolean) -> Unit) {
    val url = "http://localhost:8000/vehicles/${vehicle.id}"
    val jsonBody = gson.toJson(vehicle)
    val request = JsonArrayRequest(url, jsonBody, Response.Listener { response ->
        completion(true)
    }, Response.ErrorListener { error ->
        Log.e("VehicleManagerAPI", "Error: $error")
        completion(false)
    })
    requestQueue.add(request)
}

fun deleteVehicle(id: Int, completion: (Boolean) -> Unit) {
    val url = "http://localhost:8000/vehicles/$id"
    val request = JsonArrayRequest(url, null, Response.Listener { response ->
        completion(true)
    }, Response.ErrorListener { error ->
        Log.e("VehicleManagerAPI", "Error: $error")
        completion(false)
    })
    requestQueue.add(request)
}

}

This class provides four methods for interacting with the Vehicle Manager API:

* `getVehicles`: Retrieves a list of all vehicles
* `addVehicle`: Adds a new vehicle
* `updateVehicle`: Updates a vehicle
* `deleteVehicle`: Deletes a vehicle

**Integrating the Vehicle Manager API**

Now that we have created the Vehicle Manager API, let's integrate it with our Android app.

1. In the `MainActivity` class, create an instance of the `VehicleManagerAPI` class:
```kotlin
private lateinit var vehicleManagerAPI: VehicleManagerAPI

1. In the onCreate method, initialize the VehicleManagerAPI instance:

   vehicleManagerAPI = VehicleManagerAPI(this)

2. Use the VehicleManagerAPI instance to retrieve the list of vehicles:

   vehicleManagerAPI.getVehicles { vehicles ->
   // Handle the list of vehicles
   }

3. Use the VehicleManagerAPI instance to add a new vehicle:

   val vehicle = Vehicle("ABC123", "Toyota", "Corolla", 2015)
   vehicleManagerAPI.addVehicle(vehicle) { success ->
   if (success) {
       // Vehicle added successfully
   } else {
       // Error adding vehicle
   }
   }

4. Use the VehicleManagerAPI instance to update a vehicle:

   val vehicle = Vehicle(1, "ABC123", "Toyota", "Corolla", 2015)
   vehicleManagerAPI.updateVehicle(vehicle) { success ->
   if (success) {
       // Vehicle updated successfully
   } else {
       // Error updating vehicle
   }
   }

5. Use the VehicleManagerAPI instance to delete a vehicle:

   vehicleManagerAPI.deleteVehicle(1) { success ->
   if (success) {
       // Vehicle deleted successfully
   } else {
       // Error deleting vehicle
   }
   }

   That's it! You now have a complete tutorial on how to use the Vehicle Manager with a PHP backend and an Android app built using Kotlin.