iOS development--load, swipe and scroll through a large number of image solutions

load, swipe and scroll through a large number of image solutionsShare a private album today, read load, swipe through a large number of image solutions, I would like to emphasize that the concept of programming is not related to platform constraints. I would like to say in detail, after clicking on any small thumbnail in the thumbnail interface, into the high-definition Full Screen browsing interface of this short 1 seconds (and the next few seconds), what happened. General thinking process Click on any small map, 1. First make ScrollView frame: size 2 ScrollView, small for gesture Zoom single picture, Large horizontal loading all photos 2. After making the ScrollView frame, load the photo 3. All ready jump page presents to the user to choose a large image load picture This step, if the album within 10 photos, then no technical challenges, but if it is 300 photos? A direct crash? or let the user wait for the load? Time-intensive task, this step needs to be split and optimized. ScrollView Framework needs to understand the next API, and then move the brain, here is a little trick, a lot of people ask me how the black edge between photos and photos how to achieve, hehe, put the code:

2. #define PADDING 20
4. -(Nsinteger) Loadphotos
6. {
8. //photo before cleaning
10. For (UIView *v in [_scrollview subviews]) {
12. [v Removefromsuperview];
14. }
18. Workingframe = [[UIScreen mainscreen]bounds];
20. workingframe.origin.x = PADDING;
24. For (int i = 0; i < int_total; i++) {
26. CGRect frame = workingframe;
28. Wqphoto *photoview = [[Wqphoto alloc] initwithframe:frame];
30. [PhotoView setscroller:self];
32. [PhotoView setindex:i];
36. Wqalbumphoto *photo = [Albumobject._photos objectatindex:i];
38. [Photo Cleanthumbnail];
40. if (i = = int_current) {
42. //Load Original
44. [PhotoView SetImage:photo.oriImage];
46. [PhotoView Setisload:yes];
48. }Else if (int_current-10 < i && i < Int_current + ten) {
50. //load thumbnails near and around
52. [PhotoView SetImage:photo.thumbnail4view];
54. }
58. [_scrollview Addsubview:photoview];
60. workingframe.origin.x = workingframe.origin.x + 2 * PADDING
62. + workingFrame.size.width;
64. }
68. //Implement scrollable
70. [_scrollview Setcontentsize:cgsizemake (Workingframe.origin.x, WORKINGFRAME.SIZE.HEIGHT/2)];
72. [_scrollview setcontentoffset:cgpointmake (int_current, 0)];
74. //load remaining thumbnail images
76. Loadthread = [[Nsthread alloc]initwithtarget:self selector: @selector (loadimages) Object:nil];
78. return 0;
80. }

Use the low-resolution diagram to think carefully, in fact, there is no need to load all the pictures of the high-definition original, in advance to save each map supporting the low-resolution diagram, with space to change time. First load all the pictures of the low-resolution graph, when the user browses to a picture, the real-time loading of the original size HD uncensored large image. Process optimization: multi-threaded tasksEven so, when the number of photos reached a certain amount, the time required to consume is not a millisecond level, experience can not be satisfied, page jumps will still appear in the phenomenon of Dayton. Then consider using multithreading to further split the task, perform a jump and then perform the process of loading the low-resolution graph in the background. Optimize your quick-flip experienceWith this split, you can immediately jump and experience satisfaction. However, when browsing, when the user quickly swipe left and right, the chance of a black screen is very high, because the load of the low-resolution graph task may still be a lot of IO operation, not in time to keep up. In order to improve it, to load the low-resolution diagram of the steps to decompose again, excellence.
Within the allowable range of page jump time, load the high-definition artwork of the user-selected image, and load as many as possible a low-resolution picture of the neighboring pictures.
How do I load the rest of the low-resolution graphs? To the user click on the selected map to the center of the load, the direct thinking should be two threads a left and right load, and then think about the loading can actually be a cycle, free of those who are the cost of the thread.

2. -(BOOL) loadimages
4. {
6. For (int i = int_current-10, j = int_current + ten;!) (i < 0 && Int_total-1 < j);-I, ++j) {
8. if (! ( I < 0)) {
10. Wqphoto *photo_pre = [_scrollview.subviews objectatindex:i];
12. Wqalbumphoto *photopre = [Albumobject._photos objectatindex:i];
14. [Photo_pre SetImage:photoPre.thumbnail4view];
16. }
18. if (! ( Int_total-1 < J)) {
20. Wqphoto *photo_next = [_scrollview.subviews objectatindex:j];
22. Wqalbumphoto *photonext = [Albumobject._photos objectatindex:j];
24. [Photo_next SetImage:photoNext.thumbnail4view];
26. }
28. }
30. return YES;
32. }

And finally a slash to minimize memory consumption. Because the original image is much larger than the low-resolution graph, when the user browses from one image to another, the current picture is loaded into a large, high-definition image of the original size, and the original is replaced with a low-resolution graph. Although the number of read and write increased, but memory does save a lot.

To tell you the truth, there are a lot of albums on the market, the app, will have a lag in the jumping feeling, hehe ... P.S.The next summary discussion, how independent developers do not spend a penny of the promotion, and ultimately achieve profitability: Welcome to Exchange

iOS development--load, swipe and scroll through a large number of image solutions