ios - example - download alamofire swift 3

Descarga de AlamoFire en sesión de fondo

Question

Estoy usando Alamofire dentro de una nueva aplicación (Un ejemplo de Download Manager basado en Alamofire) Necesito algunas aclaraciones sobre la descarga de archivos usando la sesión en segundo plano. Necesito anular SessionDelegate para que funcione? ¿O simplemente backgroundCompletionHandler ?

Normalmente, ¿cuáles son los pasos para manejar las descargas en segundo plano con Alamofire? ¿Y cómo puedo manejar el caso donde mi aplicación es relarativa, con descargas en flujo? Gracias y saludos.

Answer 1

Actualizar

Basado en este increíble tutorial , he reunido un proyecto de ejemplo disponible en GitHub . Tiene un ejemplo para la gestión de sesiones en segundo plano.

De acuerdo con la Guía de programación del sistema de carga de URL de Apple:

Tanto en iOS como en OS X, cuando el usuario relanza su aplicación, debe crear inmediatamente objetos de configuración en segundo plano con los mismos identificadores que cualquier sesión que tuvo tareas pendientes cuando se ejecutó por última vez, y luego crear una sesión para cada uno de esos objetos de configuración . Estas nuevas sesiones también se reasocian automáticamente con la actividad de fondo en curso.

Aparentemente, al usar las instancias de configuración de sesión de fondo apropiadas, sus descargas nunca estarán "en flujo".

También encontré esta respuesta realmente útil.

Respuesta original

Desde la página de GitHub de Alamofire:

Las aplicaciones pueden crear gerentes para sesiones de fondo y efímeras, así como también nuevos administradores que personalizan la configuración de sesión predeterminada, como por ejemplo los encabezados predeterminados (HTTPAdditionalHeaders) o el intervalo de tiempo de espera (timeoutIntervalForRequest).

De forma predeterminada, los métodos de nivel superior usan una instancia de Manager compartido con la configuración de sesión predeterminada. Sin embargo, puede crear un administrador con la configuración de la sesión en segundo plano así:

let configuration = NSURLSessionConfiguration.backgroundSessionConfigurationWithIdentifier("com.example.app.background")
let manager = Alamofire.Manager(configuration: configuration)

A continuación, puede realizar solicitudes utilizando esta instancia de Manager .

manager.startRequestsImmediately = true
let request = NSURLRequest(URL: NSURL(string: "your.url.here")!)
manager.request(request)

Al observar su implementación, también tiene una propiedad llamada backgroundCompletionHandler , por lo que puede agregar un bloque de finalización:

manager.backgroundCompletionHandler = {
        // do something when the request has finished
    }

Answer 2

En realidad, es muy fácil con Alamofire:

1) su Alamofire.Manager debe configurarse con un identificador de sesión de fondo:

class NetworkManager {
    ...
    private lazy var backgroundManager: Alamofire.SessionManager = {
        let bundleIdentifier = ...
        return Alamofire.SessionManager(configuration: URLSessionConfiguration.background(withIdentifier: bundleIdentifier + ".background"))
    }()
    ...
}

2) en la aplicación App Delegate implement application(_:handleEventsForBackgroundURLSession:completionHandler: y pase el controlador de finalización a Alamofire.SessionManager.backgroundCompletionHandler .

En mi caso, el método de delegado de aplicación parece

func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
    NetworkManager.default.backgroundCompletionHandler = completionHandler
}

y mi administrador de red tiene una propiedad calculada como esta para establecer la propiedad Manager:

var backgroundCompletionHandler: (() -> Void)? {
    get {
        return backgroundManager.backgroundCompletionHandler
    }
    set {
        backgroundManager.backgroundCompletionHandler = newValue
    }
}

Answer 3

Estaba buscando la solución bastante larga. Hasta leer el artículo mencionado anteriormente. El problema para mí fue: tuve que habilitar la comunicación de accesorios externos

Todo lo demás fue hecho como se describe arriba. AppDelegate:

func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
        BackendAPIManager.sharedInstance.backgroundCompletionHandler = completionHandler
    }

Semifallo:

import Alamofire

class BackendAPIManager: NSObject {
    static let sharedInstance = BackendAPIManager()

    var alamoFireManager : Alamofire.SessionManager!

    var backgroundCompletionHandler: (() -> Void)? {
        get {
            return alamoFireManager?.backgroundCompletionHandler
        }
        set {
            alamoFireManager?.backgroundCompletionHandler = newValue
        }
    }

    fileprivate override init()
    {
        let configuration = URLSessionConfiguration.background(withIdentifier: "com.url.background")
        configuration.timeoutIntervalForRequest = 200 // seconds
        configuration.timeoutIntervalForResource = 200
        self.alamoFireManager = Alamofire.SessionManager(configuration: configuration)
    }
}

Y las llamadas se realizan de la siguiente manera:

BackendAPIManager.sharedInstance.alamoFireManager.upload(multipartFormData: { (multipartFormData) in ...