Picture viewer based on Android

Abstract

The invention discloses a picture viewer based on Android, and aims to provide efficient and smooth picture browsing experience for a user. The picture viewer comprises a picture loading module, a picture browsing module, a picture management module, a performance optimization module, a multimedia editing module, a social sharing module and a label management function. Smooth sliding switching, double-finger zooming and asynchronous loading are realized by integrating a ViewPager component, a gesture detection tool and a picture loading library. And the performance optimization module improves the stability and the operation efficiency of the application through memory management and cache strategies. According to the method and the system, the user is supported to edit, manage and share the pictures, the diversified requirements of the user on picture viewing and management in different scenes are met, and the method and the system have good compatibility and user experience.

Description

Technical Field

[0001] The present invention relates to the technical field of mobile application software, and particularly to an Android-based image viewer. Background Art

[0002] With the popularization of smart phones and the development of mobile Internet, users' demand for viewing and managing images on mobile devices has increased significantly. Existing image viewers still have many deficiencies in terms of operation convenience, function richness, and performance optimization, and cannot fully meet users' needs. For example, the interface operation of traditional image viewers is complex and lacks intuitive interaction methods. Especially when browsing a large number of images, the user experience is poor. In addition, when loading large-size images, existing applications often have problems such as slow loading and memory overflow, which affect the overall fluency and stability.

[0003] In terms of operation experience, the support of existing image viewers for touch screens is limited, and users cannot perform operations such as sliding, zooming, and browsing on images through intuitive gesture operations, resulting in a cumbersome use process. At the same time, with the wide application of social networks, users' demand for image sharing functions is also gradually increasing, but most traditional image viewers lack convenient sharing functions and cannot meet users' immediate sharing needs.

[0004] In addition, the existing image management functions are relatively single, lacking functions such as classification management, history record management, and tag management of images, resulting in low efficiency when users search for or re-browse specific images. In terms of performance, traditional image viewers have problems such as large memory consumption and easy memory leakage when processing high-resolution images, which affect the stability of the application and the user experience.

[0005] Therefore, there is an urgent need for an image viewer that can significantly improve in terms of operation convenience, function richness, and performance optimization to meet users' diverse needs for viewing, managing, and sharing images on mobile devices such as smart phones. Based on this background, the present invention proposes an Android-based image viewer, which comprehensively improves the user experience during the image browsing process through the design and integration of multiple modules. Summary of the Invention

[0006] The present invention provides an Android-based image viewer, aiming to provide users with an efficient and smooth image browsing experience. With the popularization of smart phones and the increasing demand of users for image browsing on mobile devices, existing image viewers have deficiencies in terms of operation convenience, performance optimization, and function diversity. The present invention effectively solves these problems through the design and integration of multiple modules.

[0007] The image viewer of the present invention includes the following main modules:

[0008] Image Loading Module: Used to load images from a storage device, perform format conversion and compression to improve the efficiency of image loading and reduce memory consumption.

[0009] Image Browsing Module: Based on the full-touch operation of Android, it supports functions such as sliding switching, two-finger zooming, scrolling, and dragging of images, enabling users to interact with images in an intuitive way. This module uses the ViewPager component to implement the sliding switching of images and combines the GestureDetector and ScaleGestureDetector for gesture operations.

[0010] Image Management Module: Used to manage the user's image collection, including browsing history, image favorites, and classification management functions. This module integrates a database to store the user's browsing history and the collection of favorite images, facilitating the user to view the browsed images at any time.

[0011] Performance Optimization Module: By means of memory management and caching strategies, it reduces the image loading time, prevents memory overflow, and improves the running stability of the application. This module improves the memory usage efficiency by releasing the references of objects that are no longer in use and using WeakReference to manage the images in memory.

[0012] Multimedia Editing Module: Provides simple editing functions for images, including cropping, adding watermarks, and adjusting the image size, meeting the user's needs for personalized image processing.

[0013] Social Sharing Module: Allows users to share the viewed images through third-party social media platforms, enhancing the social interactivity of the application.

[0014] Tag Management and Search Function: Supports users to add tags to images for convenient quick retrieval.

[0015] Advantages of the present invention:

[0016] I. Enhance user experience

[0017] Simplify operations: Traditional mobile phone image viewers may rely on keyboard keys or complex operation interfaces, while the Android-based image viewer makes full use of the full-touch features of the Android system, enabling users to browse images through simple gesture operations such as sliding and clicking, greatly simplifying the operation process.

[0018] Enhance interactivity: By integrating high-quality, interactive image viewing functions such as two-finger zooming, scrolling, and dragging, it provides users with a smooth zooming and panning experience, enhancing the interactivity between users and images.

[0019] II. Meet diverse needs

[0020] Adapt to different devices: Due to the wide popularity and diversity of the Android platform, Android-based image viewers need to have good compatibility and be able to adapt to different versions of the Android system and various models of mobile devices.

[0021] Support multiple functions: In addition to the basic image browsing function, it can also integrate diverse functions according to user needs, such as saving browsing records, browsing historical pictures, multi-touch zooming, slide show, thumbnail display, adding watermark information, modifying image size, etc., to meet the usage requirements of users in different scenarios.

[0022] III. Promote technological progress

[0023] Technological innovation: The development of Android-based image viewers requires continuous exploration and application of new technical means. For example, using Android's ScaleGestureDetector and GestureDetector for gesture detection, and combining with the Matrix class for image transformation. These technological innovations not only improve the performance of the image viewer but also provide useful references for the development of other applications.

[0024] Promote the development of the open-source community: Many Android-based image viewer projects are open-source, such as PhotoView, etc. The existence of these projects not only provides rich resources and references for developers but also promotes the development and growth of the open-source community.

[0025] IV. Commercial application prospects

[0026] Market demand: With the popularization of smartphones and the development of mobile Internet, users' demand for high-quality and easy-to-use image viewers is increasing continuously, which provides a broad market space for the commercial application of Android-based image viewers.

[0027] Profit model: By providing high-quality image viewing services, developers can achieve profitability through various means such as advertising, paid downloads, and value-added services, bringing considerable economic benefits to developers. Specific implementation manners

[0028] The present invention will be described in detail below in conjunction with specific embodiments. At the same time, it should be noted here that in order to make the embodiments more detailed, the following embodiments are the best and preferred embodiments. For some well-known technologies, those skilled in the art can also adopt other alternative ways for implementation.

[0029] It should be noted that in the specification, the mention of "an embodiment", "embodiment", "exemplary embodiment", "some embodiments", etc. indicates that the described embodiments may include specific features, structures or characteristics, but not necessarily every embodiment includes such specific features, structures or characteristics. Additionally, when combining embodiments to describe a specific feature, structure or characteristic, implementing such feature, structure or characteristic in combination with other embodiments (whether explicitly described or not) should be within the knowledge of those skilled in the relevant art.

[0030] Generally, terms can be understood at least in part from their use in context. For example, at least in part depending on the context, the term "one or more" as used herein can be used to describe any feature, structure or characteristic in a singular sense, or can be used to describe a combination of features, structures or characteristics in a plural sense. Additionally, the term "based on" can be understood as not necessarily intended to convey a set of exclusive factors, but rather can alternatively, at least in part depending on the context, allow for the existence of other factors that are not necessarily explicitly described.

[0031] Embodiment 1

[0032] Android Development Environment Setup and Configuration.

[0033] 1. Install Java Development Kit (JDK):

[0034] Android development requires the use of the Java programming language, so JDK needs to be installed first. It is recommended to install JDK 8 or a higher version.

[0035] 1. Download the JDK installer: Visit the official Oracle website or other trusted sources to download the JDK installer for Windows.

[0036] 2. Run the installer: Double-click the downloaded installer and follow the prompts for installation. Remember the installation directory location as the environment variables need to be configured later.

[0037] 2. Install Android Studio:

[0038] Android Studio is the official Android integrated development environment (IDE) for Android application development.

[0039] 1. Download Android Studio: Visit the official Android developer website to download the latest version of Android Studio.

[0040] 2. Run the installer: Double-click the downloaded installer and follow the prompts to install. During the installation process, you can choose to install the Android Virtual Device (AVD) Manager and other related components.

[0041] 3. Configure the Android SDK:

[0042] The Android SDK contains the tools, platforms, and APIs required for Android development.

[0043] 1. Open Android Studio. When running it for the first time, you will be prompted to configure the Android SDK.

[0044] 2. If not prompted, in Android Studio, click "File" > "Settings" >

[0045] "Appearance & Behavior" > "System Settings" > "Android SDK", and then click the "Edit" button.

[0046] 3. In the SDK Platforms tab, select the desired Android version, and then click the "Apply" button.

[0047] 4. In the SDK Tools tab, ensure that the required tools (e.g., Android SDK Build - Tools and Android Emulator) are selected, and then click "Apply".

[0048] 4. Set environment variables:

[0049] To enable command - line tools and Android Studio to access Android development tools, some environment variables need to be configured.

[0050] 1. Right - click "This PC" (or Computer), and then select "Properties".

[0051] 2. Click "Advanced system settings".

[0052] 3. Under the "Advanced" tab, click the "Environment Variables" button.

[0053] 4. In the "System Variables" section, find the "Path" (or "PATH") variable, and then click "Edit".

[0054] 5. Add the paths of the Android SDK tools and platform tools to the end of the variable value. For example:

[0055] C:\Users\YourUsername\AppData\Local\Android\Sdk\platform-tools and

[0056] C:\Users\YourUsername\AppData\Local\Android\Sdk\tools. Ensure the paths are separated by semicolons.

[0057] 6. Click "OK" to save the environment variable settings.

[0058] 5. Launch Android Studio:

[0059] Open Android Studio, create or import an Android project, and then you can start developing Android applications.

[0060] These are the basic steps to set up and configure the Android development environment on Windows. Ensure that your computer meets the hardware requirements of Android Studio and keep the Android SDK and related tools up to date for smooth Android application development.

[0061] II. User Interface and Adapter

[0062] 1. Android User Interface Design Principles.

[0063] Android user interface design has some important principles to ensure that the application is attractive and easy to use in terms of user experience and appearance. The following are some important Android user interface design principles:

[0064] 1. Consistency: Maintaining consistency in user interface elements is key. Similar functions or operations should look and behave the same throughout the application. This includes colors, fonts, icons, button styles, etc.

[0065] 2. Simplicity: Simplicity is a core principle of design. The user interface should be as simple as possible, avoiding excessive complexity and clutter. A clear and straightforward design makes it easier for users to understand and use the application.

[0066] 3. Feedback: Providing timely feedback is crucial for the user experience. For example, when the user performs an action, the application should provide visual or auditory feedback to confirm that the action has been successfully completed.

[0067] 4. Navigation: Users should be able to easily navigate through the application. Use clear navigation menus, tabs, or buttons to guide users through different screens and functions.

[0068] 5. Touchability: Android devices are touchscreen devices, so the application should be optimized for touch operations. Buttons and action elements should be large enough for users to easily click on them.

[0069] 6. Information Hierarchy: Organize information in a hierarchical manner to ensure that important information is more prominent and less important information can be accessed when needed. Use headings, font sizes, and colors to indicate the importance of information.

[0070] 7. Accessibility: The design should take into account different user needs, including visual impairments, hearing impairments, and other special needs. Provide text labels, screen reader support, and easily clickable elements to ensure that the application is user-friendly for all users.

[0071] 8. Backward Navigation: Provide a simple way to navigate backward so that users can return to the previous screen or step, preventing users from getting stuck in a state where they can't go back.

[0072] 9. Immediate Feedback: Load the application quickly and display content immediately, avoiding long waits. Use loading indicators to let users know that a process is in progress.

[0073] 10. Customization: Allow users to customize the appearance and functionality of the application to some extent to meet their personalized needs.

[0074] 11. Testing and Feedback: Conduct user testing during the design process and actively collect user feedback. Continuously improve and optimize the user interface to reflect user needs and feedback.

[0075] These principles help ensure that the user interface of Android applications is both aesthetically pleasing and easy to use, providing an excellent user experience. When designing Android applications, designers and developers should always keep these principles in mind to create successful applications.

[0076] 2. Use XML layouts to create the basic interface of an image viewer.

[0077] ①ConstraintLayout

[0078] 1. Relative Positioning: ConstraintLayout uses relative positioning to define the positional relationships between views. The positions of views can be defined by connecting them to the parent or other views.

[0079] 2. Drag-and-Drop and Auto-connect: Android Studio provides a visual editor that allows views to be easily dragged and automatically connected to other views or guidelines.

[0080] 3. Guidelines: ConstraintLayout allows horizontal and vertical guidelines to be added to assist in positioning and aligning views.

[0081] 4. ConstraintSets: Different constraint sets can be switched at runtime to change the layout.

[0082] 5. Aspect Ratio Constraint: The aspect ratio of a view can be specified. ConstraintLayout is a very powerful layout tool that supports many advanced features such as chained constraints, animation support, and multi-level constraints. With these features, developers can more easily create complex user interfaces that adapt to different screen sizes and orientations.

[0083] ② Draw the button background

[0084] In Android, custom shapes can be created using XML files and these shapes can be used to draw backgrounds, buttons, icons, etc. to beautify the user interface. The shape definition language used in Android is called "shapedrawable" and it typically includes shapes such as rectangles, rounded rectangles, ovals, lines, and rings.

[0085] The following is a simple Android ShapeDrawable XML example for creating a red rounded rectangle background:

[0086] The above XML code defines a shape that is a rounded rectangle with a corner radius of 10dp and a fill color of red.

[0087] This XML file can be saved in the res / drawable directory and used as the background for views in a layout file. For example, use this ShapeDrawable as the background in the layout of a button:

[0088] In the above code, the android:background attribute specifies the background of the button, which uses the ShapeDrawable we defined earlier.

[0089] The color, size, border, etc. of the shape can be changed by modifying the attribute values in the XML file. This is a simple and powerful way to create custom backgrounds and shapes to meet UI design requirements. In addition to the above example, ShapeDrawable also supports other attributes

[0090] such as borders, gradients, transparency, etc., which can be adjusted as needed.

[0091] 3. Explanation of Adapters

[0092] ①arrayAdapter

[0093] ArrayAdapter is an adapter class in Android used to bind a data set to views. It is commonly used to display data from a data set (such as an array or a list) in view controls like ListView, GridView, or Spinner.

[0094] Detailed Explanation:

[0095] ArrayAdapter is a subclass of BaseAdapter that simplifies the process of binding a data set to views. With

[0096] ArrayAdapter, it is easy to bind the data in the data set to each item in the view without writing complex adapter code.

[0097] ②simpleAdapter

[0098] SimpleAdapter is an adapter class in Android used to bind data to view controls such as ListView or GridView. It is commonly used to display simple data items, where each data item is represented by a Map object that contains key-value pairs of the data item.

[0099] Detailed Explanation:

[0100] SimpleAdapter is a subclass of BaseAdapter and is used to bind the data in the dataset to the view controls in the layout resource. Different from ArrayAdapter, SimpleAdapter is usually used in the case where each data item in the dataset has different fields. Generally, each data item in the dataset is represented by a Map object, which contains key-value pairs. The key is the field name associated with the view control, and the value is the actual value of the data item.

[0101] First, we prepared a dataset dataList, where each data item is a Map object that contains key-value pairs representing the fruit name and color. Then, we defined an array of field names from, which are associated with the keys of the data items, and then defined an array of view control IDs to corresponding to the fields. Finally, we created a SimpleAdapter to bind the data to the views, and then associated the adapter with the ListView to display the data items in the ListView.

[0102] We first prepared a dataset dataList, where each data item is a Map object that contains key-value pairs representing the fruit name and color. Then, we defined an array of field names from, which are associated with the keys of the data items, and then defined an array of view control IDs to corresponding to the fields. Finally, we created a SimpleAdapter to bind the data to the views, and then associated the adapter with the ListView to display the data items in the ListView.

[0103] We first prepared a dataset dataList, where each data item is a Map object that contains key-value pairs representing the fruit name and color. Then, we defined an array of field names from, which are associated with the keys of the data items, and then defined an array of view control IDs to corresponding to the fields. Finally, we created a SimpleAdapter to bind the data to the views, and then associated the adapter with the ListView to display the data items in the ListView.

[0104] SimpleAdapter is a convenient adapter class suitable for simple datasets. In practical applications, the adapter can be customized according to needs using different layout resources, datasets, and fields to meet various display requirements.

[0105] ③baseAdapter

[0106] BaseAdapter is an abstract adapter class in Android that provides greater flexibility, allowing custom adapters to adapt to different data structures and layout requirements. Although BaseAdapter is relatively more complex, it can be used to handle various complex datasets and custom layouts.

[0107] First, create a custom adapter class that inherits from BaseAdapter:

[0108] We created a custom adapter class named CustomAdapter that inherits from

[0109] BaseAdapter. The constructor accepts the context and the dataset (a list of strings in this example). Then, we implemented the getCount(), getItem(), getItemId(), and getView() methods to define the behavior of the adapter.

[0110] Next, create a layout file list_item.xml to display the view of each list item. Finally, use CustomAdapter in the Activity

[0111] We created a custom adapter called CustomAdapter and associated it with ListView to display the data items in the dataset. The adapter is responsible for binding data to views, while list_item.xml defines the layout of each list item. This approach allows for more flexible customization of the adapter to meet different data and view requirements.

[0112]

[0113] III. Explanation of ViewPager and Dot Indicators

[0114] 1. Image Loading and Display

[0115] In Android, ViewPager can be used to create an image viewer for loading and displaying images. The following is an example demonstrating how to use ViewPager to load and display images:

[0116] Next, create a layout file that contains ViewPager (e.g., activity_main.xml)

[0117] 2. Button Click to Jump

[0118] First, draw the background image of the button and create btn_bg.xml under drawable

[0119] Modify the activity_main.xml layout file, add two buttons and an image to the layout. Modify MainActivity to add click events to the buttons

[0120] IV. Performance Optimization and Open Function Exercises

[0121] Copy MainActivity to MainActivity2 and copy activity_main.xml to activity_main2.xml. The optimized code will be modified in MainActivity2 and activity_main2.xml.

[0122] ViewPager is a widely used component in Android applications, but performance issues may occur when dealing with a large number of pages or large images. The following are the performance optimization points for ViewPager:

[0123] ​1. Use ViewPager2: If your project uses the AndroidX library, it is recommended to use ViewPager2 to replace the old

[0124] ViewPager. ViewPager2 is a modern component with better performance and more features, such as supporting vertical scrolling.

[0125] 2. Reduce the number of pages: If possible, reduce the number of pages in the ViewPager. A large number of pages will result in more memory usage and decreased sliding performance. Consider using paging loading or on-demand loading to handle large amounts of data.

[0126] 3. Image optimization: If the ViewPager contains a large number of images, ensure that these images are optimized. Use appropriate image compression and scaling to reduce memory usage and loading time. Additionally, you can use an image loading library (such as Picasso, Glide) to handle image loading and caching, and to avoid out-of-memory errors.

[0127] ViewPager2

[0128] ViewPager2 has many improvements and advantages over ViewPager, especially in terms of performance, features, and lifecycle management. The following are some of the main advantages of ViewPager2 over ViewPager:

[0129] 1. More modern API: ViewPager2 is part of the AndroidX library and uses a more modern Android architecture and components. This makes it easier to integrate with other AndroidX components and gain the latest Android development features and optimizations.

[0130] 2. Support for vertical swiping: ViewPager2 supports vertical swiping, while ViewPager only supports horizontal swiping. This makes it easier to create swipe pages in the vertical scrolling direction.

[0131] 3. More flexible adapter: ViewPager2 uses RecyclerView.Adapter as the adapter, which provides more flexibility and features. You can easily use RecyclerView.Adapter with ViewPager2 without having to create a custom adapter.

[0132] 4. Customizable page transition animations: ViewPager2 allows you to easily customize page transition animations, unlike ViewPager which is restricted. This means you can implement richer and more complex page transition effects.

[0133] 5. Page lifecycle management: ViewPager2 provides better page lifecycle management through FragmentStateAdapter and FragmentPagerAdapter. This means that invisible pages can be more easily destroyed to free up memory resources, while visible pages can be retained in memory.

[0134] 6. Dataset update support: ViewPager2 supports dynamic dataset updates, which means you can add, delete, or update pages at runtime without causing the application to crash or become inconsistent.

[0135] 7. RTL (right-to-left) language support: ViewPager2 provides better support for applications that support right-to-left (RTL) languages, ensuring correct page arrangement and swipe directions.

[0136] 8. Built-in touch event handling: ViewPager2 has built-in more powerful touch event handling and can easily support various gesture operations such as clicks, swipes, and zooms.

[0137] In summary, ViewPager2 is a more modern, feature-rich, and better-performing page sliding component, especially suitable for scenarios such as image viewers, navigation tabs, and other scenarios that require sliding pages in Android applications. If you are developing a new application or upgrading an existing application, it is strongly recommended to consider using ViewPager2 instead of the old version of ViewPager.

[0138] Optimized code example:

[0139] In the project, make sure to add the dependency of ViewPager2. Add the following dependency in the build.gradle file:

[0140] implementation 'androidx.viewpager2:viewpager2:1.0.0'

[0141] 2. Image loading optimization

[0142] Image loading and display are handled by the Picasso library, which is an excellent image loading library that can efficiently load and cache images.

[0143] Picasso is a popular Android image loading library used for asynchronous loading, caching, and displaying images. Compared with directly using ImageView, Picasso has many advantages:

[0144] 1. Asynchronous Loading: Picasso supports asynchronous image loading, which means it can load images in a background thread without blocking the main thread, thus improving the responsiveness of the application.

[0145] 2. Image Caching: Picasso has a built-in image caching mechanism that can cache loaded images for quick access later. This reduces multiple requests to the network and improves the performance of the application.

[0146] 3. Automatic Image Resizing: Picasso can automatically resize images to fit the dimensions of the ImageView, thus reducing memory usage. This helps avoid memory overflow caused by loading overly large images.

[0147] 4. Error Handling: Picasso has a built-in error handling mechanism that can handle various error situations when loading images, such as network errors, failed image loading, etc. You can set default placeholder images or error images to provide a better user experience.

[0148] 5. Easy to Use: Loading images with Picasso is very simple and can be done with just one line of code. This reduces the workload of developers and improves the readability of the code.

[0149] 6. Automatic Request Cancellation: Picasso can automatically cancel previous image loading requests to avoid loading too many unnecessary images. This is very useful for situations like lists and scroll views that require frequent image loading.

[0150] 7. Supports Multiple Data Sources: Picasso not only supports loading images from the network but also from various data sources such as local resources, files, URIs, content providers, etc., so it is very flexible.

[0151] 8. Optimized Memory Management: Picasso automatically manages memory caching and the recycling of bitmap resources to prevent memory leaks and application crashes.

[0152] 9. Custom Transformations and Requests: Picasso allows you to customize image loading requests, including resizing, rotation, transformation, and setting custom transformers, etc.

[0153] 10. Activity Binding: Picasso has an activity binding feature that can automatically cancel image loading requests at the appropriate times in the Activity or Fragment lifecycle to prevent image loading in a destroyed Activity.

[0154] Generally speaking, Picasso is a powerful and easy-to-use image loading library that provides many convenient features to help developers handle image loading and display more easily, while improving the performance and user experience of the application. Therefore, it is one of the preferred libraries for many Android developers.

[0155] The following is an example of using Picasso to asynchronously load and display an image.

[0156] First, ensure that the Picasso library dependency has been added to the project. Add the following dependency in the build.gradle file:

[0157] implementation 'com.squareup.picasso:picasso:2.71828'

[0158] Then modify the onBindViewHolder method in the ImagePagerAdapter

[0159] 3. Release memory to improve performance

[0160] In Android development, releasing variables is a common performance optimization strategy that can help reduce memory usage and improve the performance of the application. The following are some common methods and best practices for releasing variables:

[0161] 1. Release objects that are no longer needed in a timely manner: When an object is no longer needed, its reference should be immediately set to null. This allows the garbage collector to recycle the object early and release the memory resources. For example:

[0162] 2. Manually release resources: For some Android components (such as database connections, file handles, etc.), not only should they be closed in a timely manner, but they should also be manually released when they are no longer needed. For example, close the database connection in the onDestroy method.

[0163] 3. Avoid memory leaks: Memory leaks are a common performance issue. Ensure that references to objects are not accidentally retained to prevent memory leaks. Use weak references (WeakReference) or soft references (SoftReference) to hold object references so that the garbage collector can automatically release objects that are no longer needed.

[0164] 4. Avoid unnecessary caching: Caching can improve performance, but if not used carefully, it can also cause excessive memory consumption. Ensure that only the data that needs to be cached is cached, and clean up the cached data that is no longer needed in a timely manner.

[0165] 5. Optimize data structures: Select appropriate data structures to store and manage data. Sometimes, using the right data structure can reduce memory consumption. For example, use SparseArray instead of HashMap to store data with a large number of integer keys.

[0166] 6. Use WeakReference and SoftReference: For certain objects, if you don't want them to affect garbage collection, you can use WeakReference or SoftReference to wrap their references. In this way, when memory is tight, the garbage collector can more easily recycle these objects.

[0167] 7. Use memory analysis tools: Android provides some memory analysis tools, such as Android Profiler and LeakCanary, which can help identify memory leaks and places where memory is overly consumed.

[0168] 8. Conduct performance tests regularly: Most importantly, conduct performance tests and analysis regularly to identify and solve performance problems. Performance optimization is an ongoing process, and it is very important to continuously conduct performance tests and improve the code.

[0169] In summary, releasing variables and resources that are no longer needed is one of the important steps to improve the performance of Android applications. By reasonably managing memory and resources, it is possible to ensure that the application is more efficient and stable.

[0170] When the Activity is destroyed, release resources manually and override the onDestroy method of MainActivity2.

[0171] 4. Open - ended function practice

[0172] In an existing Android photo viewer application, the student's task is to design and implement a new functional module.

[0173] Task requirements:

[0174] 1. Function description: The student's task is to design and implement a new functional module, which can be any function related to the photo viewer,

[0175] such as photo sharing, commenting, tagging, searching, etc. The specific content of the function is chosen by the student himself / herself, but it must be in line with the theme of the photo viewer.

[0176] 2. UI design: The student needs to create a user interface related to the new function. This includes designing layouts, views, buttons, menus, etc., so that users can easily use the new function.

[0177] 3. Functional implementation: Students need to implement the core logic of the new function. This may involve coding work in aspects such as data storage, network requests, data processing, and user interaction. Students should ensure the normal operation and stability of the function.

[0178] 4. Testing and debugging: Students need to conduct testing and debugging of the function to ensure there are no errors or exceptions. They can use mock data or actual data to test the function.

[0179] 5. Documentation and comments: Students need to write appropriate documentation and comments to explain the working principle and usage of the new function. This includes adding comments in the code, writing a user manual, or a function description.

[0180] 6. Demonstration and presentation: Students need to prepare a demonstration or presentation to showcase their new function. They can demonstrate the working principle and usage of the function to other students or teachers and answer related questions.

[0181] V. System Testing

[0182] 1. System Testing

[0183] 1. UI Testing (UITesting):

[0184] Test sliding and zooming: Use a UI testing framework (such as Espresso) to test that users can correctly slide and zoom pictures.

[0185] Test user interface response: Test whether the clicks and interactions of user interface elements (such as buttons, menu items, toolbars, etc.) are normal.

[0186] Test picture download and sharing: Test whether the picture download and sharing functions work as expected.

[0187] 2. Performance Testing (PerformanceTesting):

[0188] Load performance testing: Test the performance of picture loading, including loading speed and memory occupancy.

[0189] Sliding performance testing: Test the performance of sliding pages to ensure smoothness even with a large number of pictures.

[0190] Cache performance testing: Test the performance of cache management to ensure it does not cause memory leaks or performance degradation.

[0191] 3. Stability Testing (StressTesting):

[0192] Large-scale picture testing: Conduct tests under the simulation of a large number of pictures to ensure the application remains stable under high load.

[0193] Low-memory test: Simulate tests under low-memory conditions to ensure that the application does not crash under memory stress.

[0194] This invention covers any alternatives, modifications, equivalent methods, and solutions made within the spirit and scope of this invention. To enable the public to have a thorough understanding of this invention, specific details are described in detail in the following preferred embodiments of this invention. However, those skilled in the art can fully understand this invention even without the description of these details. Additionally, well-known methods, processes, flows, components, and circuits, etc., are not described in detail to avoid unnecessary confusion to the essence of this invention.

[0195] The above are only the preferred embodiments of this invention. It should be noted that for those of ordinary skill in the art, without departing from the principle of this invention, several improvements and refinements can be made, and these improvements and refinements should also be regarded as within the protection scope of this invention.

Claims

1. An Android-based picture viewer, characterized in that: The image viewer includes the following modules: The image loading module is used to load images from storage devices and perform format conversion and compression to improve loading efficiency; The picture browsing module is based on Android's full touch operation and supports picture sliding switching, pinch-to-zoom, scrolling, dragging and other functions; The picture management module is used to manage the user's picture collection, including browsing history, picture collection, and classification management functions; The performance optimization module reduces image loading time, prevents memory overflow, and improves application operation stability based on memory management and cache strategies.

2. The Android-based picture viewer according to claim 1, characterized in that: The picture browsing module uses the ViewPager component to implement sliding switching of pictures, and combines GestureDetector and ScaleGestureDetector to implement gesture operations.

3. The Android-based picture viewer according to claim 1, characterized in that: The image loading module integrates image loading libraries such as Picasso or Glide to achieve asynchronous loading and caching of images.

4. The Android-based picture viewer according to claim 1, characterized in that: The picture management module includes a database for storing the user's browsing history and collection of pictures, so that the user can review the browsed pictures at different time points.

5. The Android-based picture viewer according to claim 1, characterized in that: The performance optimization module releases unused object references and uses WeakReference to manage images in memory to improve memory usage efficiency.

6. The Android-based picture viewer according to claim 1, characterized in that: The picture viewer also includes a multimedia editing module for performing simple editing operations on the pictures, including cropping, adding watermarks and adjusting picture sizes.

7. The Android-based picture viewer according to claim 1, characterized in that: The picture browsing module supports a slide show mode, and the user can select the picture play order and time interval.

8. The Android-based picture viewer according to claim 1, characterized in that: The picture viewer also includes a social sharing module, allowing users to share the viewed pictures through a third-party social media platform.

9. The Android-based picture viewer according to claim 1, characterized in that: The picture management module supports the function of adding tags to pictures, so that users can quickly search for pictures.

10. The Android-based picture viewer according to claim 1, characterized in that: The image viewer adopts an adapter mode to support different types of data sources, including local storage and cloud storage, to achieve unified management and browsing of images.