La comunicación entre un cliente móvil y un servidor backend es fundamental en el desarrollo de aplicaciones. Para aplicaciones iOS, existen diversas estrategias para establecer esta conexión. A continuación, se detalla un método para interactuar con un servidor desarrollado en Python utilizando el framework Flask, desde una apliacción iOS escrita en Swift.

Escenario de Uso

Consideremos la construcción de una aplicación de mensajería básica. El frontend se implementará en Swift para iOS, y el backend se desarrollará con Flask en Python. El objetivo es permitir a los usuarios enviar mensajes y recuperar el historial de conversaciones.

Implementación

Servidor Back end (Flask)

Primero, configuramos un servidor Flask que exponga una API REST para gestionar las solicitudes de mensajes de los usuarios.

from flask import Flask, request, jsonify

app = Flask(__name__)
chat_history = []

@app.route('/post_message', methods=['POST'])
def handle_message():
   """Endpoint para recibir y almacenar nuevos mensajes."""
   data = request.get_json()
   if 'content' in data:
       chat_history.append(data['content'])
       return jsonify({"status": "ok", "messages": chat_history}), 201
   else:
       return jsonify({"status": "error", "message": "Missing 'content' field"}), 400

@app.route('/get_history', methods=['GET'])
def retrieve_messages():
   """Endpoint para obtener todos los mensajes actuales."""
   return jsonify({"messages": chat_history}), 200

if __name__ == '__main__':
   # Ejecutar el servidor en modo debug en la dirección local y puerto 5000
   app.run(host='0.0.0.0', port=5000, debug=True)
   

Este código define dos rutas:

• /post_message: Maneja las peticiones POST para enviar nuevos mensajes.
• /get_history: Atiende las peticiones GET para recuperar la lista completa de mensajes.

Cliente Frontend (Swift)

En la aplicación iOS, utilizaremos URLSession para realizar las solicitudes de red. El siguiente fragmento muestra cómo enviar un mensaje y obtener el historial.

import SwiftUI // O UIKit, si se prefiere

struct ContentView: View {
   @State private var messageInput: String = ""
   @State private var chatMessages: [String] = []
   let apiBaseURL = "http://localhost:5000" // Asegúrate que la IP y puerto sean correctos

   var body: some View {
       VStack {
           List(chatMessages, id: \.self) { message in
               Text(message)
           }
           HStack {
               TextField("Escribe tu mensaje...", text: $messageInput)
                   .textFieldStyle(RoundedBorderTextFieldStyle())
               Button("Enviar") {
                   sendMessage()
               }
           }
           .padding()
       }
       .onAppear {
           fetchChatHistory()
       }
   }

   func sendMessage() {
       guard let url = URL(string: "\(apiBaseURL)/post_message") else { return }
       var request = URLRequest(url: url)
       request.httpMethod = "POST"
       request.setValue("application/json", forHTTPHeaderField: "Content-Type")

       let payload: [String: Any] = ["content": messageInput]
       guard let httpBody = try? JSONSerialization.data(withJSONObject: payload) else {
           print("Error al serializar los datos del mensaje.")
           return
       }
       request.httpBody = httpBody

       let task = URLSession.shared.dataTask(with: request) { data, response, error in
           if let error = error {
               print("Error al enviar mensaje: \(error.localizedDescription)")
               return
           }

           if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 201 {
               print("Mensaje enviado con éxito.")
               // Actualizar la vista con el nuevo historial
               DispatchQueue.main.async {
                   fetchChatHistory()
                   messageInput = "" // Limpiar el campo de entrada
               }
           } else {
               print("Respuesta inesperada del servidor.")
           }
       }
       task.resume()
   }

   func fetchChatHistory() {
       guard let url = URL(string: "\(apiBaseURL)/get_history") else { return }

       let task = URLSession.shared.dataTask(with: url) { data, response, error in
           if let error = error {
               print("Error al obtener historial: \(error.localizedDescription)")
               return
           }

           if let data = data, let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 {
               if let decodedResponse = try? JSONDecoder().decode(ChatHistoryResponse.self, from: data) {
                   DispatchQueue.main.async {
                       self.chatMessages = decodedResponse.messages
                   }
               } else {
                   print("Error al decodificar la respuesta JSON.")
               }
           } else {
               print("Respuesta no exitosa del servidor al obtener historial.")
           }
       }
       task.resume()
   }
}

// Estructura para decodificar la respuesta del historial de chat
struct ChatHistoryResponse: Codable {
   let messages: [String]
}

// Para previsualización en SwiftUI
struct ContentView_Previews: PreviewProvider {
   static var previews: some View {
       ContentView()
   }
}
   

El código Swift:

• Define la función sendMessage para enviar datos JSON vía POST.
• Implementa fetchChatHistory para obtener los mensajes mediante una petición GET.
• Utiliza URLSession para la comunicación de red.
• Actualiza la interfaz de usuario con los datos recibidos.

Consideraciones Adicionales

Este ejemplo proporciona una base funcional. Para aplicaciones de producción, se deben implementar características como la autenticación de usuarios, manejo de errores robusto, persistencia de datos y comuniccación en tiempo real (por ejemplo, usando WebSockets) para una experiencia de usuario mejorada.