Cannot decode Base64 string swift - ios

I'm trying to decode the following Base64 encoded string :
/9j/4AAQSkZJRgABAQAASABIAAD/4QBYRXhpZgAATU0AKgAAAAgAAgESAAMAAAABAAEAAIdpAAQAAAABAAAAJgAAAAAAA6ABAAMAAAABAAEAAKACAAQAAAABAAAAZKADAAQAAAABAAAAZAAAAAD/7QA4UGhvdG9zaG9wIDMuMAA4QklNBAQAAAAAAAA4QklNBCUAAAAAABDUHYzZjwCyBOmACZjs%2BEJ%2B/8AAEQgAZABkAwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5%2Bv/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIBAgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uLj5OXm5%2Bjp6vLz9PX29/j5%2Bv/bAEMABgYGBgYGCgYGCg4KCgoOEg4ODg4SFxISEhISFxwXFxcXFxccHBwcHBwcHCIiIiIiIicnJycnLCwsLCwsLCwsLP/bAEMBBwcHCwoLEwoKEy4fGh8uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLi4uLv/dAAQAB//aAAwDAQACEQMRAD8A5RRzQ3ApwppORXkbnqsRT%2BlSZ/WoRx0p2T0oEPY0ufSoycinE/nSEP8AapFqHdUyE4oEPJ4pm7PWkJ600dKaGTDpTxzmoh6VJnAHvT8xodlh0o3P/nNJn8aTPsfypDuf/9DlScc1ESM1XknUDINV/tIPf2rybM9Rsv8AendqpC4BFSCZSDzQ0xXLQx%2BtIxzUe8c0p5ANLURMD39qnHtVVXHSpQwPFKwhxPU03dtxUbPjj0qFnLNj0q0BeU0pfnNVEfjNPDZOfShIZZ3Ubvaq4Zu1LlvWpsVY/9Hyh5ye9V2mPY1SaTioml9a4lA9Bs1PtLDvUgvCKxPMNJvPrT5ES5M6QXw45xU5vwRjNcr5lL5vPWj2aFznVLfDd1qUXwx1rkhMc9acZyO9T7JBznUm%2BX1pUuhk%2B9ckZzkDPvU8dyQetP2Yc52CzDirCsMZrl47v3rSgus8VDgaJmyCcdcUc%2BtU/NLcgmjefU1nZlH/0vCC1RliaZmjNc52Dt3FGaYTSE0xDy1JuphNGaYh%2B7FG4mmE00mhITY/JzmpAxFQCnZp2BFtXI71aiuCvOayw1SB6mw7nRLdgr1Ip32of3jWD5jDpR5r%2BtZ%2BzK52f//T%2Bfc96XPFIPekJrA6x2eKaemKTNJnmmIdmgU2lzQIM%2BlJnmkJpuaaEPzS7qjzxS54pgPyelGcGm03PNAFkOv8VLvSqxOaTIpWC5//1Pn3NNPtSdqaaxOpsdTaM8UUxCmlpBTScGmICaQ0UgoELmkBpvenUwFJpAc00mlFAC4J6Uu003NJQB//1fnjP8qTNH%2BFB7VkjqY3PFO7Uw9Kf/hQSgzxTG60/wDhpjdaoGA5FGaB92k9KBC44zSdqd2pg6UwFpDxS0jdKAGnrSZobrSUAf/Z
It is valid as I have tested it using Online Base64 to Image Converter and it displays fine. I use the following code :
let thumbData = NSData(base64EncodedString: thumbnaill, options: NSDataBase64DecodingOptions(rawValue: 0))
if let b = thumbData {
let thumb = UIImage(data: b)
curr_item.thumbnail = thumb
}
The problem is thumbData is always nil. I'm not sure what I'm doing wrong.

The "base64" data you provided above is URL-encoded. E.g. it has %2B in place of "+" characters. If that's not a copy/paste error, and your actual data is URL-encoded, you need to remove that encoding first before decoding it. Something like this:
if let decoded = thumbnaill.stringByRemovingPercentEncoding {
let thumbData = NSData(base64EncodedString: decoded, options: NSDataBase64DecodingOptions(rawValue: 0))
} else {
print("Couldn't decode string")
}

Related

Cant decode Base64 string into image?

I have a Base64 string and want to turn it into an image, here is my func:
let imageString = speaker.image
if let decodedData = Data(base64Encoded: imageString, options: .ignoreUnknownCharacters) {
let image = UIImage(data: decodedData)
speakerCell.speakerImage.image = image
}
If I paste the below test code into a web browser, it decodes the image correctly, but the same string in the app fails.
It fails the if let and skips over, I can't understand why...
data:image/jpg;base64,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
Remove data:image/jpg;base64, from the beginning, your code will work without it.
let imageString = speaker.image.replacingOccurrences(of: "data:image/jpg;base64,", with: "")

Convert UIImage to base64 string in swift

I'm trying to convert a UIImage to a base64 string with the goal of uploading it to a back-end server.
However, the conversion code I found in this article (which should be Apple's own implementation) generates an invalid string:
Convert between UIImage and Base64 string
After upload, I get this image:
[Failty image that is decoded from iOS converted base64 1
Instead of this:
[Correct image decoded from an online base64 conversion tool2
I tested the upload results using Postman and the back-end handles a valid base64 image correctly, so I narrowed the bug down to the base64 conversion itself. Here's my code:
public extension UIImage
{
func base64Encode() -> String?
{
guard let imageData = UIImagePNGRepresentation(self) else
{
return nil
}
let base64String = imageData.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.Encoding64CharacterLineLength)
let fullBase64String = "data:image/png;base64,\(base64String))"
return fullBase64String
}
}
Any idea how I could fix my base64 output on my iOS device before I upload it to the server?
Do it something like this:
For Encoding:
data.base64EncodedStringWithOptions([])
For decoding:
let url = URL(string: String(format:"data:application/octet-stream;base64,%#",base64String))
do {
let data = try Data(contentsOf: url!)
}catch {
}
for Swift 4,
Do something like this,
For Encoding -
let imgObj = UIImage(named: "photo")
let imageData = UIImagePNGRepresentation(imgObj!)! as NSData
let base64 = imageData.base64EncodedData(options: .lineLength64Characters)
datatype of base64 variable is Data.

Decoding base64String into UIImage in Swift 2

I have a base64String that I need to convert into a UIImage() and display in a UIImageView. I've been trying for hours to convert it, but I keep getting nil from UIImage(data: data). When I print(data)it looks normal, but I can't decode it properly into an image. What's going on, and why is this code not working?
let base64String = "data:image/x-icon;base64,AAABAAEAEBAAAAAAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAAAAAAAAAAAAAAAAAAAAAAAA2Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf88IjD/XUlU/2RRW/9GLzv/kouQ/6Sdn/84Hiz/RCs4/0QrOP82Gyn/Nhop/0UtOv9FLDr/OR8t/zYaKf85Hyz/ubO2////////////7+/v//////+6tbb/RS47/+bl5v/Py87/OR4s/0gxPf/z8/P/vrq8/1dFTv82Gin/a1xk//////+4s7f/hnuB//b29v/+/v7/SjdC/0EoNv/5+Pn/39zg/zgdK/9oWGD//////5OIjf9ELTn/Nhop/6CYnP//////X0xW/zYaKf/Cvb///////0czPv9AJzX/9vX2/+Dc3/86Hy7/lIqP//////9jUlr/OB0s/zYaKf+qpKb//////2ZSXf82Gin/zcbJ//////9RPkf/QCc1//X19f/c2Nv/Pyc0/8nGyP/8/Pz/RzA8/zYaKf82Gin/q6Wn//////9kUVv/Nhop/83Gyf//////UD1G/0AnNf/19fX/1NDT/0w4RP/5+fn/zcnL/zkfLf82Gin/Nhop/6ulp///////ZFFb/zYaKf/Nxsn//////1A9Rv9AJzX/8fDx//n4+f/U0NP//////6GYnP82Gin/Nhop/zYaKf+rpaf//////2RRW/82Gin/zcbJ//////9QPUb/QCc0//Dv7///////+vr6///////39vf/RzM//zYbKf82Gin/q6Wn//////9kUVv/Nhop/83Gyf//////UD1G/0AnNP/19PT/4N3e/0s0QP+HfIL//////5uRlv9HLzv/Nhop/6ylp///////ZFFb/zYaKf/Nxsn//////1A9Rv9AJzT/9fX1/9zZ2v85Hiz/VD9K//////+7tLf/VkJM/zYaKf+po6X//////2RRW/82Gin/xb3C//////9OPEX/QCc0//b19f/c2tr/OR4s/1I9SP//////t7Gz/1M/SP82Gin/joWJ//////98b3b/Ri47/9XS1P//////STI+/0MpNv/y8fH/6+np/3FfaP+poab//////46Dif9CKjf/Nhop/0c0P//39vf///////r6+///////pp+k/zYaKf9GLjr/8O/v//////////////////Dv7/9AKjb/Nhop/zYaKf82Gin/UkBJ/7Osrv/DvsD/joSJ/zkhLv82Gin/PCIw/35wdv+GeH7/hHd8/39yef9HMT3/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/Nhop/zYaKf82Gin/AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//wAA//8AAP//AAD//w="
let decodedData = NSData(base64EncodedString: base64String, options: NSDataBase64DecodingOptions.IgnoreUnknownCharacters)
print(decodedData) // prints out fine
let image = UIImage(data: decodedData!) // keep getting nil here
use this function for decode Base64 String to String
public func decodebase64(str : String) -> String{
let decodedData = NSData(base64EncodedString: str, options:NSDataBase64DecodingOptions(rawValue: 0))
let decodedString = String(data: decodedData!, encoding: NSUTF8StringEncoding)
return decodedString!}
then use this function in this way
let newimage:String? = decodebase64(busimage)
if (newimage?.characters.count != 0)
{
ImageLoader.sharedLoader.imageForUrl(newimage!) { (images, url) -> () in
if (images != nil)
{
cell.compnylogo.image = images!
}
}
}
here you have to just use. or drag and drop this swift file.
Use this image Loader File this will help you

NSDataBase64DecodingOptions always returns nil

There are a lot of similar questions but non of them helped me out so I just don't know what to do but ask. So this is how I encode a UIImage:
let data: NSData = UIImagePNGRepresentation(imageResized)!
let base64String: NSString = data.base64EncodedStringWithOptions(.Encoding64CharacterLineLength)
and decoding (as suggested here):
if let range = base64.rangeOfString("data:image/png;base64,", options: .AnchoredSearch) {
base64.removeRange(range)
}
let decodedData = NSData(base64EncodedString: base64, options: NSDataBase64DecodingOptions(rawValue: 0))
if let decodedImage = UIImage(data: decodedData!) {
self.imageList.append(decodedImage)
}
But the app crashes when initializing decodedData and I can't figure out why.
I checked my base64 string here and it returns the picture.
Any help will be very appreciated!
Try with this:
if let decodedData = NSData(base64EncodedString: base64, options:NSDataBase64DecodingOptions.IgnoreUnknownCharacters){
if(decodedData.length > 0){
let imageDecodeData = UIImage(data: decodedData)!
}
else{
print("error")
}
}
Replace the line with let decodedData with:
let decodedData = NSData(base64EncodedString: base64, options: [])
And also make sure that your using correct variables:
// 1. This should be a variable if you're mutating it.
let base64String = data...
// 2. You should probably do this on your base64String
if let range = base64.rangeOfString(...)

Encoding/Decoding base64 decodedData = nil

Yesterday I wrote a working code for this, but I erased it and when writing a new one something is really weird:
I encode it a picture this way:
let pictureData = UIImagePNGRepresentation(picture!)
let pictureToString64 = pictureData?.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.Encoding64CharacterLineLength)
(I had JPEGRepresentation before, but it wasn't working, so I tried with JPEG)
and I decode this way by getting pic 64 which I believe it has the correct value. It starts with iVBORw0KGgoAAAANSUhEUgAAAUAA(...)
let decodedData = NSData(base64EncodedString: pic64, options:NSDataBase64DecodingOptions(rawValue: 0))
let decodedImage = UIImage(data: decodedData!)
let pictureDataLocal = UIImageJPEGRepresentation(decodedImage!, 100)
defaults.setObject(pictureDataLocal, forKey: "profilePicture")
The problem is that decodedData is always nil. Why is this happening?
I think this has to do with NSDataBase64DecodingOptions.
Using NSDataBase64DecodingOptions.IgnoreUnknownCharacters instead of NSDataBase64DecodingOptions(rawValue: 0), I was able to decode the Base64 encoded string back into NSData, and created a UIImage from that data:
let picture = UIImage(named: "myImage")
let pictureData = UIImagePNGRepresentation(picture!)
let pictureToString64 = pictureData?.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.Encoding64CharacterLineLength)
let decodedData = NSData(base64EncodedString: pictureToString64!, options:NSDataBase64DecodingOptions.IgnoreUnknownCharacters)
let decodedImage = UIImage(data: decodedData!)
let pictureDataLocal = UIImageJPEGRepresentation(decodedImage!, 100)
NSDataBase64DecodingOptions inherits from OptionSetType which is why you get the rawValue initializer. It is better to use the one of the set types, rather passing in a value. I saw in the header that NSDataBase64DecodingOptions was the only public var in the struct, so I tried it.
#available(iOS 7.0, *)
public struct NSDataBase64DecodingOptions : OptionSetType {
public init(rawValue: UInt)
// Use the following option to modify the decoding algorithm so that it ignores unknown non-Base64 bytes, including line ending characters.
public static var IgnoreUnknownCharacters: NSDataBase64DecodingOptions { get }
}

Resources