ios - ¿Determinar el tipo MIME de NSData?

objective-c mime-types

Question

¿Cómo determinarías el tipo mime para un objeto NSData? Planeo que el usuario cargue un video / imagen de su iPhone y que ese archivo se incluya en una clase de NSData.

Me preguntaba si puedo distinguir el tipo mime de NSData. Solo hay algunas respuestas a esta pregunta y la más reciente es de 2010 (¡hace 4 años!). ¡Gracias!

NSData *data; // can be an image or video
NSString *mimeType = [data getMimetype]; // how would I implement getMimeType

Answer 1

Basándome en la respuesta de ml de una publicación similar , he agregado la determinación de tipos mime para NSData:

ObjC:

+ (NSString *)mimeTypeForData:(NSData *)data {
    uint8_t c;
    [data getBytes:&c length:1];

    switch (c) {
        case 0xFF:
            return @"image/jpeg";
            break;
        case 0x89:
            return @"image/png";
            break;
        case 0x47:
            return @"image/gif";
            break;
        case 0x49:
        case 0x4D:
            return @"image/tiff";
            break;
        case 0x25:
            return @"application/pdf";
            break;
        case 0xD0:
            return @"application/vnd";
            break;
        case 0x46:
            return @"text/plain";
            break;
        default:
            return @"application/octet-stream";
    }
    return nil;
}

Rápido:

static func mimeType(for data: Data) -> String {

    var b: UInt8 = 0
    data.copyBytes(to: &b, count: 1)

    switch b {
    case 0xFF:
        return "image/jpeg"
    case 0x89:
        return "image/png"
    case 0x47:
        return "image/gif"
    case 0x4D, 0x49:
        return "image/tiff"
    case 0x25:
        return "application/pdf"
    case 0xD0:
        return "application/vnd"
    case 0x46:
        return "text/plain"
    default:
        return "application/octet-stream"
    }
}

Este solo controla los tipos de archivos principales, pero puede completarlo para que se ajuste a sus necesidades: todos los archivos de firma están disponibles en.wikipedia.org/wiki/List_of_file_signatures , solo use el mismo patrón que yo.

PD: todos los tipos de mimos correspondientes están disponibles here

Answer 2

Como dice que está cargando estos datos, ya debería saber el tipo MIME. Usted creó el objeto de datos, sabe de dónde provienen los datos y hay un número limitado de tipos MIME. Así que usa el que se aplique a tus datos. Para una imagen es probablemente image/jpeg o image/png . Para los videos hay un montón de video/ tipos. Puede encontrar una larga lista de cadenas de tipo MIME en su Mac en /etc/apache2/mime.types . Querrás uno o más de esos dependiendo de qué tipo de video tengas.

Determinar el tipo MIME es un problema pegajoso; Un NSData puede codificar cualquier tipo de datos binarios. La única manera de determinar qué fue codificado es examinar los bytes. Eso, a su vez, significa tener cierta comprensión de qué flujos de bytes existen en diferentes tipos de archivos. Debería ser posible utilizar un diccionario de búsqueda en muchos casos (pero no en todos), y podría haber una implementación de código abierto en algún lugar para los tipos de archivos comunes. Para tener una idea de lo que está involucrado, pruebe el man file en su Mac y busque en /usr/share/file/magic/ para ver cómo se identifican los distintos tipos de archivos (el comando de file no produce tipos MIME pero sí analiza el contenido del archivo) para tratar de identificar los tipos de archivos, por lo que es el mismo principio).

Answer 3

Que yo sepa, NSData es solo un objeto de datos que envuelve una matriz de bytes:

https://developer.apple.com/library/mac/documentation/Cocoa/Reference/Foundation/Classes/NSData_Class/Reference/Reference.html

... así que una forma en la que puedo pensar si desea descubrir su tipo MIME es inspeccionar los bytes en sí mismos y luego suponer el tipo a partir de ahí. Hay un ejemplo de eso aquí: Encontrar el tipo de imagen de NSData o UIImage

También encontré esto: Determine el tipo MIME de NSData cargados de un archivo ; que se refiere a alguna base de datos interna (supongo) que se puede usar para una búsqueda de tipo MIME.

Pero como dice Tom Harrington en su respuesta, podría ser difícil dependiendo de con qué estés lidiando.

Editar...

Por supuesto, esa segunda solución se basa en la extensión de archivo, que obviamente no tiene, pero estoy seguro de que ya lo ha notado.

Answer 4

valores var = [UInt8] (repitiendo: 0, cuenta: imgData.count)

imgData.copyBytes (a: & valores, cuenta: 1)

    switch values {
    case 0xff:
        return "image/jpeg"
    case 0x89:
        return "image/png"
    case 0x47:
        return "image/gif"
    case 0x49, 0x4d:
        return "image/tiff"
    }

    return ""

Answer 5

❤️ Swift

extension Data {
    private static let mimeTypeSignatures: [UInt8 : String] = [
        0xFF : "image/jpeg",
        0x89 : "image/png",
        0x47 : "image/gif",
        0x49 : "image/tiff",
        0x4D : "image/tiff",
        0x25 : "application/pdf",
        0xD0 : "application/vnd",
        0x46 : "text/plain",
        ]

    var mimeType: String {
        var c: UInt8 = 0
        copyBytes(to: &c, count: 1)
        return Data.mimeTypeSignatures[c] ?? "application/octet-stream"
    }
}