Encoding/Decoding base64 decodedData = nil - ios

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 }
}

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: "")

cannot assign value of type 'UIImage?' to type 'NSData?' in swift 3

I am using CoreData for an app. I have set image as BinaryData in data model. But I have fetched image from server as UIImage and it throws error as:
cannot assign value of type 'UIImage?' to type 'NSData?
I searched but couldn't find any resemblance solution for it. Can anyone help me in swift 3?
My code is:
let url1:URL = URL(string:self.appDictionary.value(forKey: "image") as! String)!
let picture = "http://54.243.11.100/storage/images/news/f/"
let strInterval = String(format:"%#%#",picture as CVarArg,url1 as CVarArg) as String as String
let url = URL(string: strInterval as String)
SDWebImageManager.shared().downloadImage(with: url, options: [],progress: nil, completed: {[weak self] (image, error, cached, finished, url) in
if self != nil {
task.imagenews = image //Error:cannot assign value of type 'UIImage?' to type 'NSData?'
}
})
The error message is pretty clear - you cannot assign UIImage object to a variable of NSData type.
To convert UIImage to Swift's Data type, use UIImagePNGRepresentation
var data : Data = UIImagePNGRepresentation(image)
Note that if you're using Swift, you should be using Swift's type Data instead of NSData
You must convert, image into Data (or NSData) to support imagenews data type.
Try this
let url1:URL = URL(string:self.appDictionary.value(forKey: "image") as! String)!
let picture = "http://54.243.11.100/storage/images/news/f/"
let strInterval = String(format:"%#%#",picture as CVarArg,url1 as CVarArg) as String as String
let url = URL(string: strInterval as String)
SDWebImageManager.shared().downloadImage(with: url, options: [],progress: nil, completed: {[weak self] (image, error, cached, finished, url) in
if self != nil {
if let data = img.pngRepresentationData { // If image type is PNG
task.imagenews = data
} else if let data = img.jpegRepresentationData { // If image type is JPG/JPEG
task.imagenews = data
}
}
})
// UIImage extension, helps to convert Image into data
extension UIImage {
var pngRepresentationData: Data? {
return UIImagePNGRepresentation(img)
}
var jpegRepresentationData: Data? {
return UIImageJPEGRepresentation(self, 1.0)
}
}

I want to encode and decode a UIImage to and from a String for a value in AEXML in swift

//To encode I found the following example. I don't know if it works yet
#IBAction func exitImageViewController(seque:UIStoryboardSegue){
let imageController = seque.destination as! MyImageViewController
let myView = imageController.imageView
imageData = UIImagePNGRepresentation((myView?.image!)!)
imageString = imageData?.base64EncodedString()
// Is this swift code correct?
//I cannot find an example of decoding String back to UIImage
The code you posted looks fine. To encode back you can do this:
let data = Data(base64Encoded: imageString!)
let img = UIImage(data: 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(...)

Resources