Scrollez la vue et la vue de tableau des performances lors du chargement des images du disque

L'image du disque est en réalité lue lors du dessin de l'image sur l'imageView. Même si nous mettons en cache la lecture de l'image du disque, cela n'affecte pas car il ne conserve que la référence au fichier. Vous devrez peut-être utiliser un carrelage d'images plus grandes à cette fin.

Cordialement, Deepa

Vous devriez consulter l'application de l'exemple LazyTableImages.

Si vous avez réduit l'activité de réseau, j'essaierais d'encapsuler votre demande pour vous assurer qu'elle est à 100% du fil principal. Bien que vous puissiez utiliser NsurlConnection de manière asynchrone et répondre à ses méthodes de déléguement, je trouve plus facile d'envelopper une demande synchrone dans une opération d'arrière-plan. Vous pouvez utiliser Nsoperation ou une expédition centrale Grand si vos besoins sont plus complexes. Un exemple (relativement) simple dans une implémentation d'ImageLoader pourrait être:

// imageLoader.m

// assumes that that imageCache uses kvp to look for images
- (UIImage *)imageForKey:(NSString *)key
{
    // check if we already have the image in memory
     UImage *image = [_images objectForKey:key];

    // if we don't have an image:
    // 1) start a background task to load an image from a file or URL
    // 2) return a default image to display while loading
    if (!image) {
        [self performSelectorInBackground:@selector(loadImageForKey) withObject:key];
        image = [self defaultImage];
    }

    return image;
}

- (void)loadImageForKey:(NSString *)key
{
    NSAutoReleasePool *pool = [[NSAutoReleasePool alloc] init];

    // attempt to load the image from the file cache
    UIImage *image = [self imageFromFileForKey:key];

    // if no image, load the image from the URL
    if (!image) {
        image = [self imageFromURLForKey:key];
    }

    // if no image, return default or imageNotFound image
    if (!image) {
        image = [self notFoundImage];
    }

    if ([_delegate respondsTo:@selector(imageLoader:didLoadImage:ForKey:)]) {
        [_delegate imageLoader:self didLoadImage:image forKey:key];
    }

    [pool release];
}

- (UIImage *)imageFromURLForKey:(NSString *)key
{
    NSError *error = nil;
    NSData *imageData = [NSData dataWithContentsOfURL:[self imageURLForKey:key]
                                              options:0
                                                error:&error];

    UIImage *image;

    // handle error if necessary
    if (error) {
        image = [self errorImage];
    }

    // create image from data
    else {
        image = [UIImage imageWithData:imageData];
    }

    return image;
}

J'ai eu ce problème - vous frappez la limite de la rapidité avec laquelle l'interface utilisateur peut charger une image lors du défilement - je vais donc contourner le problème et améliorer l'expérience utilisateur.

1. Ne chargez que des images lorsque le rouleau se trouve à une nouvelle «page» (rectangle statique) et
2. Mettez un indicateur d'activité derrière une vue de défilement transparente pour gérer le cas où l'utilisateur défile plus rapidement que l'application peut charger le contenu

C'est généralement le décodage de l'image qui prend du temps, ce qui provoque une gel des interfaces internes (puisque tout se passe sur le fil principal). Chaque fois que vous appelez [UIIMAGE ImageWithData:] sur une grande image, vous remarquerez un hoquet. Décodage Une image plus petite est beaucoup plus rapide.

Deux options:

1. Vous pouvez d'abord charger une version miniature de chaque image, puis "Aiguisir" sur Didfinishscrolling . Les vignettes doivent décoder rapidement suffisamment de telle sorte que vous ignorez de cadres.
2. Vous pouvez charger une version miniature de chaque image ou afficher un indicateur de chargement en premier, puis décodez l'image de résolution complète sur un autre fil et sous le subtiliser quand il est prêt. (C'est la technique qui est utilisée dans l'application de photos indigènes).

   Je préfère la deuxième approche; C'est assez facile avec GDC de nos jours.