Les cookies dans UIWebView sont-ils acceptés?

Je dois remettre en question pour vous.

1 : je suis en utilisant UIWebViews dans mon iPhone. Je wan pas les utilisateurs pourront ajouter des commentaires dans la presse. Mais, pour commentaire qu'ils ont pour ouvrir une session.

Si non, comment puis-je accepter les cookies dans UIWebViews ?

2 : les cookies créés sur UIWebView disponibles dans d'autres UIWebView dans un autre point de Vue ?

Ex : j'ai mon LoginViewControlleravec un intégré à UIWebViewoù mon utilisateur peut se connecter/se déconnecter. Si ils se connectent dans ce point de vue, le cookie sera toujours disponible dans la CommentViewController ?

Si non, comment puis-je rendre cela possible ?

Merci d'avance !

source d'informationauteur ThibaultV

  1. 37

    La UIWebView stocke automatiquement les cookies dans le [NSHTTPCookieStorage sharedHTTPCookieStorage] collection, et devrait être disponible dans tous les autres UIWebViews au sein de votre application, au cours de la même application se lance. Cependant, le UIWebView classe ne comprend pas stocker automatiquement les cookies pour les pages qui sont chargés entre l'app se lance. Vous devez enregistrer manuellement les cookies lorsque l'application est déplacé à l'arrière-plan et de recharger les valeurs lorsque l'application est ramené au premier plan.

    Placez le code suivant dans votre AppDelegate classe:

    - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
//Other existing code
[self loadHTTPCookies];
return YES;
}
- (void)applicationDidEnterBackground:(UIApplication *)application
{
//Other existing code
[self saveHTTPCookies];
}
- (void)applicationWillEnterForeground:(UIApplication *)application
{
[self loadHTTPCookies];
}
- (void)applicationWillTerminate:(UIApplication *)application
{
//Other existing code
[self saveHTTPCookies];
}
-(void)loadHTTPCookies
{
NSMutableArray* cookieDictionary = [[NSUserDefaults standardUserDefaults] valueForKey:@"cookieArray"];
for (int i=0; i < cookieDictionary.count; i++)
{
NSMutableDictionary* cookieDictionary1 = [[NSUserDefaults standardUserDefaults] valueForKey:[cookieDictionary objectAtIndex:i]];
NSHTTPCookie *cookie = [NSHTTPCookie cookieWithProperties:cookieDictionary1];
[[NSHTTPCookieStorage sharedHTTPCookieStorage] setCookie:cookie];
}
}
-(void)saveHTTPCookies
{
NSMutableArray *cookieArray = [[NSMutableArray alloc] init];
for (NSHTTPCookie *cookie in [[NSHTTPCookieStorage sharedHTTPCookieStorage] cookies]) {
[cookieArray addObject:cookie.name];
NSMutableDictionary *cookieProperties = [NSMutableDictionary dictionary];
[cookieProperties setObject:cookie.name forKey:NSHTTPCookieName];
[cookieProperties setObject:cookie.value forKey:NSHTTPCookieValue];
[cookieProperties setObject:cookie.domain forKey:NSHTTPCookieDomain];
[cookieProperties setObject:cookie.path forKey:NSHTTPCookiePath];
[cookieProperties setObject:[NSNumber numberWithUnsignedInteger:cookie.version] forKey:NSHTTPCookieVersion];
[cookieProperties setObject:[[NSDate date] dateByAddingTimeInterval:2629743] forKey:NSHTTPCookieExpires];
[[NSUserDefaults standardUserDefaults] setValue:cookieProperties forKey:cookie.name];
[[NSUserDefaults standardUserDefaults] synchronize];
}
[[NSUserDefaults standardUserDefaults] setValue:cookieArray forKey:@"cookieArray"];
[[NSUserDefaults standardUserDefaults] synchronize];
}
  2. 11

    L'expansion de l'autre répond:

    Depuis NSHTTPCookieStorage cookies peuvent être archivés à l'aide de NSKeyedArchivervous n'avez pas besoin d'extraire chaque cookie propriété vous-même. En outre, vous voulez supprimer la NSUserDefaults témoin de la propriété, quand il n'y a pas les cookies pour stocker des.

    Sorte que vous pouvez simplifier votre cookie de stockage/chargement de cette extension:

    static NSString *const kCookiesKey = @"cookies";
@implementation NSHTTPCookieStorage (Persistence)
- (void)saveToUserDefaults
{
NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
if (self.cookies != nil && self.cookies.count > 0) {
NSData *cookieData = [NSKeyedArchiver archivedDataWithRootObject:self.cookies];
[userDefaults setObject:cookieData forKey:kCookiesKey];
} else {
[userDefaults removeObjectForKey:kCookiesKey];
}
[userDefaults synchronize];
}
- (void)loadFromUserDefaults
{
NSData *cookieData = [[NSUserDefaults standardUserDefaults] objectForKey:kCookiesKey];
if (cookieData != nil) {
NSArray *cookies = [NSKeyedUnarchiver unarchiveObjectWithData:cookieData];
for (NSHTTPCookie *cookie in cookies) {
[self setCookie:cookie];
}
}
}
@end

    Alors utilisez simplement [[NSHTTPCookieStorage sharedHTTPCookieStorage] loadFromUserDefaults]; et [[NSHTTPCookieStorage sharedHTTPCookieStorage] saveToUserDefaults]; dans votre AppDelegate comme mentionné ci-dessus.

  3. 7

    swift 3 version claire

    func saveCookies() {
guard let cookies = HTTPCookieStorage.shared.cookies else {
return
}
let array = cookies.flatMap { (cookie) -> [HTTPCookiePropertyKey: Any]? in
cookie.properties
}
UserDefaults.standard.set(array, forKey: "cookies")
UserDefaults.standard.synchronize()
}
func loadCookies() {
guard let cookies = UserDefaults.standard.value(forKey: "cookies") as? [[HTTPCookiePropertyKey: Any]] else {
return
}
cookies.forEach { (cookie) in
guard let cookie = HTTPCookie.init(properties: cookie) else {
return
}
HTTPCookieStorage.shared.setCookie(cookie)
}
}
  4. 6

    Swift 3

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any] ? ) - > Bool {
loadHTTPCookies()
return true
}
func applicationDidEnterBackground(_ application: UIApplication) {
saveCookies()
}
func applicationWillEnterForeground(_ application: UIApplication) {
loadHTTPCookies()
}
func applicationWillTerminate(_ application: UIApplication) {
saveCookies()
}
func loadHTTPCookies() {
if let cookieDict = UserDefaults.standard.value(forKey: "cookieArray") as? NSMutableArray {
for c in cookieDict {
let cookies = UserDefaults.standard.value(forKey: c as!String) as!NSDictionary
let cookie = HTTPCookie(properties: cookies as![HTTPCookiePropertyKey: Any])
HTTPCookieStorage.shared.setCookie(cookie!)
}
}
}
func saveCookies() {
let cookieArray = NSMutableArray()
if let savedC = HTTPCookieStorage.shared.cookies {
for c: HTTPCookie in savedC {
let cookieProps = NSMutableDictionary()
cookieArray.add(c.name)
cookieProps.setValue(c.name, forKey: HTTPCookiePropertyKey.name.rawValue)
cookieProps.setValue(c.value, forKey: HTTPCookiePropertyKey.value.rawValue)
cookieProps.setValue(c.domain, forKey: HTTPCookiePropertyKey.domain.rawValue)
cookieProps.setValue(c.path, forKey: HTTPCookiePropertyKey.path.rawValue)
cookieProps.setValue(c.version, forKey: HTTPCookiePropertyKey.version.rawValue)
cookieProps.setValue(NSDate().addingTimeInterval(2629743), forKey: HTTPCookiePropertyKey.expires.rawValue)
UserDefaults.standard.setValue(cookieProps, forKey: c.name)
UserDefaults.standard.synchronize()
}
}
UserDefaults.standard.setValue(cookieArray, forKey: "cookieArray")
}
  5. 4

    De tous les grands d'autres réponses à cette question, j'ai compilé une extension pratique sur UserDefaults qui raccourcit le code nécessaire.

    UserDefaults Extension pour Swift 3

    extension UserDefaults {
///A dictionary of properties representing a cookie.
typealias CookieProperties = [HTTPCookiePropertyKey: Any]
///The `UserDefaults` key for accessing cookies.
private static let cookieKey = "cookies"
///Saves all cookies currently in the shared `HTTPCookieStorage` to the shared `UserDefaults`.
func saveCookies() {
guard let cookies = HTTPCookieStorage.shared.cookies else {
return
}
let cookiePropertiesArray = cookies.flatMap { $0.properties }
set(cookiePropertiesArray, forKey: UserDefaults.cookieKey)
synchronize()
}
///Loads all cookies stored in the shared `UserDefaults` and adds them to the current shared `HTTPCookieStorage`.
func loadCoookies() {
let cookiePropertiesArray = value(forKey: UserDefaults.cookieKey) as? [CookieProperties]
cookiePropertiesArray?.forEach {
if let cookie = HTTPCookie(properties: $0) {
HTTPCookieStorage.shared.setCookie(cookie)
}
}
}
}

    Vous pouvez ajouter ce code dans un fichier séparé UserDefaults+Cookies.swift (par exemple) et ensuite appeler les méthodes à partir de votre AppDelegate comme décrit par Brian Shamblen dans son réponse originale à cette question:

    Des appels de AppDelegate

    func applicationDidBecomeActive(_ application: UIApplication) {
UserDefaults.standard.loadCoookies()
}
func applicationWillEnterForeground(_ application: UIApplication) {
UserDefaults.standard.loadCoookies()
}
func applicationDidEnterBackground(_ application: UIApplication) {
UserDefaults.standard.saveCookies()
}
func applicationWillTerminate(_ application: UIApplication) {
UserDefaults.standard.saveCookies()
}
  6. 3

    Ici est plus propre et plus sûr Swift version:

    private func loadCookies() {
guard let cookies = NSUserDefaults.standardUserDefaults().valueForKey("cookies") as? [[String: AnyObject]] else {
return
}
for cookieProperties in cookies {
if let cookie = NSHTTPCookie(properties: cookieProperties) {
NSHTTPCookieStorage.sharedHTTPCookieStorage().setCookie(cookie)
}
}
}
private func saveCookies() {
guard let cookies = NSHTTPCookieStorage.sharedHTTPCookieStorage().cookies else {
return
}
var array = [[String: AnyObject]]()
for cookie in cookies {
if let properties = cookie.properties {
array.append(properties)
}
}
NSUserDefaults.standardUserDefaults().setValue(array, forKey: "cookies")
NSUserDefaults.standardUserDefaults().synchronize()
}
  7. 1

    Swift Version 2.0

    func loadCookies() {
let cookieDict : NSMutableArray? = NSUserDefaults.standardUserDefaults().valueForKey("cookieArray") as? NSMutableArray
if cookieDict != nil {
for var c in cookieDict! {
let cookies = NSUserDefaults.standardUserDefaults().valueForKey(c as! String) as! NSDictionary
let cookie = NSHTTPCookie(properties: cookies as! [String : AnyObject])
NSHTTPCookieStorage.sharedHTTPCookieStorage().setCookie(cookie!)
}
}
}
func saveCookies() {
var cookieArray = NSMutableArray()
let savedC = NSHTTPCookieStorage.sharedHTTPCookieStorage().cookies
for var c : NSHTTPCookie in savedC! {
var cookieProps = NSMutableDictionary()
cookieArray.addObject(c.name)
cookieProps.setValue(c.name, forKey: NSHTTPCookieName)
cookieProps.setValue(c.value, forKey: NSHTTPCookieValue)
cookieProps.setValue(c.domain, forKey: NSHTTPCookieDomain)
cookieProps.setValue(c.path, forKey: NSHTTPCookiePath)
cookieProps.setValue(c.version, forKey: NSHTTPCookieVersion)
cookieProps.setValue(NSDate().dateByAddingTimeInterval(2629743), forKey: NSHTTPCookieExpires)
NSUserDefaults.standardUserDefaults().setValue(cookieProps, forKey: c.name)
NSUserDefaults.standardUserDefaults().synchronize()
}
NSUserDefaults.standardUserDefaults().setValue(cookieArray, forKey: "cookieArray")
}