Android Projects Research Articles

Exploring Data Persistence in Android using Room Database

This research paper explore the concept of data persistence in Android applications using Room database. In the dynamic landscape of mobile app development, ensuring efficient storage and retrieval of data is crucial for providing a seamless user experience. Room database, a powerful library provided by Android Jetpack, offers a robust solution for managing app's local database. The study delves into the key features and benefits of Room database, including its support for object-relational mapping (ORM) and simplified SQLite database interactions. By analyzing the working principles and implementation strategies of Room, this research aims to provide developers with insights into optimizing data persistence in Android applications. Additionally, the paper discusses practical examples and best practices for integrating Room database into Android projects, highlighting its role in enhancing data management capabilities and improving overall app performance. By examining the impact of Room database on data persistence in Android apps, this research contributes to the ongoing discourse on efficient storage solutions for mobile applications Keywords: Room, Android, Dao, Entity, SQLite, Recycler View, ViewHolder, Dependency, Adapter, Gradle

Understanding the quality and evolution of Android app build systems

AbstractBuild systems are used to transform static source code into executable software. They play a crucial role in modern software development and maintenance. As such, much research effort has been invested in understanding the quality and evolution of build systems, including Apache ANT, Apache Maven, and Make‐based ones. However, the quality and evolution of build systems for mobile apps, such as on the Android platform, have not as yet been investigated in detail. Mobile app development, and the Android development context in particular, impose unique constrains, such as different device conditions and capabilities. It presents unique challenges, such as frequently upgraded Android frameworks, which those who implement and maintain build systems must tackle. In this paper, we present an exploratory empirical study of the build systems of 5222 Android projects to better understand their quality and evolution. We (a) study the build technology choices that Android developers make (Gradle being recommended and the most popular choice), (b) explore the sustainability of the official Gradle build system (parts of build files are updated more frequent that others and the update of the special Gradle plugin would induce unrecommended configurations), and (c) analyze the quality of Gradle scripts for Android apps—more than a half of the open‐source Android apps cannot be successfully built due to five common root causes.

CrossFix: Resolution of GitHub issues via similar bugs recommendation

SummaryWith the increasing popularity of Open‐Source Software (OSS), the number of GitHub issues reported daily in these OSS projects has been growing rapidly. To resolve these issues, developers need to spend time and effort in debugging and fixing these issues. Meanwhile, a recent approach shows that similar bugs exist across different projects, and one could use the GitHub issues from a different project for finding new bugs for a related project. To locate similar bugs for our approach, we first conduct a study of similar bugs in GitHub. Our study redefines similar bugs as bugs that share the (1) same libraries, (2) same functionalities, (3) same reproduction steps, (4) same configurations, (5) same outcomes, or (6) same errors. Moreover, our study revealed the usefulness of similar bugs in helping developers to find more contexts about the bug and fixing. Based on our study, we design CrossFix, a tool that automatically suggests relevant GitHub issues based on an open GitHub issue. The suggested GitHub issues may contain solutions written in natural language or pull requests that help developers in resolving the given issue. Our evaluation on 249 open issues from Java and Android projects shows that CrossFix could suggest similar bugs to help developers in debugging and fixing.

PI-Link: A Ground-Truth Dataset of Links Between Pull-Requests and Issues in GitHub

GitHub hosts Git repositories and provides issues-tracking services to provide a better collaboration environment for software developers. Issues and Pull-Requests are frequently used in GitHub to discuss and review the software requirements (new features, bugs, etc.) and software solutions (source code, test cases, etc.) respectively. The links between Issues and their corresponding Pull-Requests comprise valuable information to keep tracking current development as well as documenting knowledge for future development. Considering a large number of links, such information can be used to train machine learning models for several purposes such as feature location, bug prediction and localization, recommendation systems and documentation generation. To the best of our knowledge, no dataset has been proposed as a ground-truth of links between Issues and Pull-Requests. In this paper, we propose, PI-Link, a new significant and reliable ground-truth dataset composed of 50369 links that explicitly connect 34732 Issues with 50369 Pull-Requests. These links are automatically extracted from all (907,139) Android projects in GitHub created between January 1, 2011 and January 1, 2021. To better organize and store the collected data, we propose a metamodel based on the concepts of Issues and Pull Requests. Moreover, we analyze the relationships between Issues and their linked Pull Requests based on four features related to their titles, bodies, labels and comments. The selected features are analyzed in terms of their lengths and similarities based on three lexical and one semantic similarity metrics. The results showed promising similarities between Issues and their linked PRs at the lexical and semantic levels. In addition, some feature similarities are sensitive to the text length, whereas other feature similarities are sensitive to the term frequency.

Runtime Permission Issues in Android Apps: Taxonomy, Practices, and Ways Forward

Android introduces a new permission model that allows apps to request permissions at runtime rather than at the installation time since 6.0 (Marshmallow, API level 23). While this runtime permission model provides users with greater flexibility in controlling an app's access to sensitive data and system features, it brings new challenges to app development. First, as users may grant or revoke permissions at any time while they are using an app, developers need to ensure that the app properly checks and requests required permissions before invoking any permission-protected APIs. Second, Android's permission mechanism keeps evolving and getting customized by device manufacturers. Developers are expected to comprehensively test their apps on different Android versions and device models to make sure permissions are properly requested in all situations. Unfortunately, these requirements are often impractical for developers. In practice, many Android apps suffer from various runtime permission issues (ARP issues). While existing studies have explored ARP issues, the understanding of such issues is still preliminary. To better characterize ARP issues, we performed an empirical study using 135 Stack Overflow posts that discuss ARP issues and 199 real ARP issues archived in popular open-source Android projects on GitHub. Via analyzing the data, we observed 11 types of ARP issues that commonly occur in Android apps. For each type of issues, we systematically studied: (1) how they can be manifested, (2) how pervasive and serious they are in real-world apps, and (3) how they can be fixed. We also analyzed the evolution trend of different types of issues from 2015 to 2020 to understand their impact on the Android ecosystem. Furthermore, we conducted a field survey and in-depth interviews among the practitioners from open-source community and industry, to gain insights from practitioners’ practices and learn their requirements of tools that can help combat ARP issues. Finally, to understand the strengths and weaknesses of the existing tools that can detect ARP issues, we built <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">ARPBench</small> , an open benchmark consisting of 94 real ARP issues, and evaluated the performance of three available tools. The experimental results indicate that the existing tools have very limited supports for detecting our observed issue types and report a large number of false alarms. We further analyzed the tools’ limitations and summarized the challenges of designing an effective ARP issue detection technique. We hope that our findings can shed light on future research and provide useful guidance to practitioners.

Why Did Developers Migrate Android Applications From Java to Kotlin?

Currently, the majority of apps running on mobile devices are Android apps developed in Java. However, developers can now write Android applications using a new programming language: Kotlin, which Google adopted in 2017 as an official programming language for developing Android apps. Since then, Android developers have been able to: a) start writing Android applications from scratch using Kotlin, b) evolve their existing Android applications written in Java by adding Kotlin code (possible thanks to the interoperability between the two languages), or c) migrate their Android apps from Java to Kotlin. This paper aims to study this last case. We conducted a qualitative study to find out <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">why</i> Android developers have migrated Java code to Kotlin and to bring together their experiences about the process, in order to identify the main difficulties they have faced. To execute the study, we first identified commits from open-source Android projects that have migrated Java code to Kotlin. Then, we emailed the developers that wrote those migrations. We thus obtained information from 98 developers who had migrated code from Java to Kotlin. This paper presents the main reasons identified by the study for performing the migration. We found that developers migrated Java code to Kotlin in order to access programming language features (e.g., extension functions, lambdas, smart casts) that are not available with Java for Android development, and to obtain safer code (i.e., avoid null-pointer exceptions). We also identified research directions that the research community could focus on in order to help developers to improve the experience of migrating their Java applications to Kotlin.

Fast Library Recommendation in Software Dependency Graphs with Symmetric Partially Absorbing Random Walks

To help developers discover libraries suited to their software projects, automated approaches often start from already employed libraries and recommend more based on co-occurrence patterns in other projects. The most accurate project–library recommendation systems employ Graph Neural Networks (GNNs) that learn latent node representations for link prediction. However, GNNs need to be retrained when dependency graphs are updated, for example, to recommend libraries for new projects, and are thus unwieldy for scalable deployment. To avoid retraining, we propose that recommendations can instead be performed with graph filters; by analyzing dependency graph dynamics emulating human-driven library discovery, we identify low-pass filtering with memory as a promising direction and introduce a novel filter, called symmetric partially absorbing random walks, which infers rather than trains the parameters of filters with node-specific memory to guarantee low-pass filtering. Experiments on a dependency graph between Android projects and third-party libraries show that our approach makes recommendations with a quality and diversification loosely comparable to those state-of-the-art GNNs without computationally intensive retraining for new predictions.

TECHNOLOGY OF IDENTIFYING ANTIPATTERNS IN ANDROID PROJECTS WRITTEN IN KOTLIN LANGUAGE

The problem of the lack of instruments for identifying the characteristics of low-quality code in Android projects that are written in the Kotlin language is determined. A review of modern approaches for identifying antipatterns in program code is accomplished. The analysis of the methods used to find problems with code in Android projects is performed. DECOR and Paprika approaches are considered. Conclusions are drawn about the importance of finding design flaws in program code for the mobile software development and its further support. An antipatterns identification approach for Kotlin language program code in Android projects is proposed. An algorithm for identifying low-quality Kotlin code is presented. The technology for detecting poor quality code characteristics consists of four stages: collecting metrics about an analyzed software system, building a quality model, converting a quality model into a graph representation, and identifying predefined antipatterns. The collection of metrics, including the search for both Androidspecific and object-oriented metrics of Chidamber and Kamerer, is proposed to be implemented through parsing source code and converting it into an abstract syntax tree using the KASTree library. The implementation of KASTree library usage is offered through the Adapter design pattern. The construction of a quality model is implemented using the Paprika tool, supplemented by a number of introduced metrics. Conversion of quality model exactly into graph representation is used to identify antipatterns in order to ensure the speed and quality of complex queries execution for identifying antipatterns. Antipatterns identification using database queries is based on various template rules, including the Catolino rules. Different features of applying the Cypher query language to a graph database are used to represent the rules in form of queries. Results of the work can be used in development of software for poor quality code identification in mobile applications written in Kotlin language, as well as in studies of mobile development antipatterns for this language.

Effort estimation of open source Android projects via transaction analysis

AbstractTransactions have been used in many software sizing methods to measure software functional size and provide a basis for effort estimation. To further investigate the effects that transactions have on software functional size and more accurately estimate project effort using the transactional information, in this paper, we propose a method to identify transactions, as well as their complexity attributes that are influential to software functional size, directly from the source code of Android projects using static and dynamic analyses.The identified transactions are classified into different complexity levels and applied with different weights based on their evaluated complexity levels to distinguish their effects on software functional size. A size metric called sum of weighted transactions (SWT) is proposed to measure software functional size. We calibrate an effort estimation model using SWT based on a data set of 34 open source Android projects, and show the effectiveness of using SWT as a software functional size measure to estimate project effort.

Exploring the Characteristics of Identifiers: A Large-Scale Empirical Study on 5,000 Open Source Projects

Informative identifiers are crucial for the comprehensibility and maintainability of programs. Exploring properties of identifiers and investigating their impact on software artifacts have been an important research focus. However, to enable such capabilities, fundamentally we need to have comprehensive understanding on the main characteristics of identifiers at the first place, which is unfortunately not sufficiently studied. For example, it remained unclear what Part of Speech (POS) tags that developers commonly use to define identifiers. To answer such open issues, we conducted a large-scale empirical study on the naturalness of identifiers, based on 5,000 open source Java and Android projects, concerning five dimensions of identifiers: distributions, compositions, POS tags, lengths, and initializations of identifiers. Results of the empirical study contain five key findings for identifiers in programs, including, e.g., the observation that the three POS tags (i.e., nouns, verbs, and adjectives) are the most commonly used ones when developers define identifiers. Furthermore, based on our findings, we provide implications and insights for developers, researchers, and Integrated Development Environments (IDEs) in the context that identifier-related activities are performed or functionalities are enabled.

Deep model compression for mobile platforms: A survey

Despite the rapid development of mobile and embedded hardware, directly executing computation-expensive and storage-intensive deep learning algorithms on these devices' local side remains constrained for sensory data analysis. In this paper, we first summarize the layer compression techniques for the state-of-the-art deep learning model from three categories: weight factorization and pruning, convolution decomposition, and special layer architecture designing. For each category of layer compression techniques, we quantify their storage and computation tunable by layer compression techniques and discuss their practical challenges and possible improvements. Then, we implement Android projects using TensorFlow Mobile to test these 10 compression methods and compare their practical performances in terms of accuracy, parameter size, intermediate feature size, computation, processing latency, and energy consumption. To further discuss their advantages and bottlenecks, we test their performance over four standard recognition tasks on six resource-constrained Android smartphones. Finally, we survey two types of run-time Neural Network (NN) compression techniques which are orthogonal with the layer compression techniques, run-time resource management and cost optimization with special NN architecture, which are orthogonal with the layer compression techniques.

Android Applications based on software repository analysis

Context: Software repositories have been a source for studies about software evolution and its relation to software defects. In addition, the context of repositories has also been used for the purpose of analyzing refactoring practiced by programmers throughout the development process. Objective: Our objective is based on android projects stored in software repositories, to determine what types of transformations, that is, which refactorings are used, seeking to relate them to quality and security factors. Method: This research uses as an approach an exploratory study of a qualitative character, based on a systematic review of the literature, which will be carried out between the period from 2015 to 2019, as well as the application of research and quality criteria regarding the work context. In addition, develop a case study with projects for Android, relating refactoring quality criteria to non-aggregated projects in software repositories, glimpsing comparative and resulting factors. Expected results: It is expected with this review analysis and a summary of existing literature on Code Quality in the process of Software Refactoring for Android projects. Conclusions: The research is guided by this approach in identifying the types of refactorings practiced and extracting the related quality factors in the development process. We believe that our results will benefit in the updating and summary of the literature in the context of refactoring, glimpsing comparative factors.

Scripted GUI testing of Android open-source apps: evolution of test code and fragility causes

Evidence from empirical studies suggests that mobile applications are not thoroughly tested as their desktop counterparts. In particular, GUI testing is generally limited. Like web-based applications, mobile apps suffer from GUI testing fragility, i.e., GUI test classes failing or needing interventions because of modifications in the AUT or in its GUI arrangement and definition. The objective of our study is to examine the diffusion of test classes created with a set of popular GUI Automation Frameworks for Android apps, the amount of changes required to keep test classes up to date, and the amount of code churn in existing test suites, along with the underlying modifications in the AUT that caused such modifications. We defined 12 metrics to characterize the evolution of test classes and test methods, and a taxonomy of 28 possible causes for changes to test code. To perform our experiments, we selected six widely used open-source GUI Automation Frameworks for Android apps. We evaluated the diffusion of the tools by mining the GitHub repositories featuring them, and computed our set of metrics on the projects. Applying the Grounded Theory technique, we then manually analyzed diff files of test classes written with the selected tools, to build from the ground up a taxonomy of causes for modifications of test code. We found that none of the considered GUI automation frameworks achieved a major diffusion among open-source Android projects available on GitHub. For projects featuring tests created with the selected frameworks, we found that test suites had to be modified often – specifically, about 8% of developers’ modified LOCs belonged to test code and that a relevant portion (around 50% on average) of those modifications were induced by modifications in GUI definition and arrangement. Test code written with GUI automation fromeworks proved to need significant interventions during the lifespan of a typical Android open-source project. This can be seen as an obstacle for developers to adopt this kind of test automation. The evaluations and measurements of the maintainance needed by test code wrtitten with GUI automation frameworks, and the taxonomy of modification causes, can serve as a benchmark for developers, and the basis for the formulation of actionable guidelines and the development of automated tools to help mitigating the issue.

Mobile GUI Testing Fragility: A Study on Open-Source Android Applications

Android applications do not seem to be tested as thoroughly as desktop ones. In particular, graphical user interface (GUI) testing appears generally limited. Like web-based applications, mobile apps suffer from GUI test fragility, i.e., GUI test classes failing or needing updates due to even minor modifications in the GUI or in the application under test. The objective of our study is to estimate the adoption of GUI testing frameworks among Android open-source applications, the quantity of modifications needed to keep test classes up to date, and their amount due to GUI test fragility. We introduce a set of 21 metrics to measure the adoption of testing tools and the evolution of test classes and test methods, and to estimate the fragility of test suites. We computed our metrics for six GUI testing frameworks, none of which achieved a significant adoption among Android projects hosted on GitHub. When present, GUI test methods associated with the considered tools are modified often, and a relevant portion (70% on average) of those modifications is induced by GUI-related fragilities. On average, for the projects considered, more than 7% of the total modified lines of code between consecutive releases belong to test classes developed with the analyzed testing frameworks. The measured percentage was higher on average than the one required by other generic test code, based on the JUnit testing framework. Fragility of GUI tests constitutes a relevant concern, probably an obstacle for developers to adopt test automation. This first evaluation of the fragility of Android scripted GUI testing can constitute a benchmark for developers and testers leveraging the analyzed test tools and the basis for the definition of a taxonomy of fragility causes and guidelines to mitigate the issue.

Android动态加载技术的研究

21世纪，移动互联网飞跃式的发展，全球互联网用户数量急速上升。为了满足不同用户在不同使用场景下的需求，移动应用不断推陈出新，在其不断完善的同时，人们对移动应用也产生了依赖性。移动应用已经全面的深入到人们的吃、穿、住、行等方方面面。所以，为了适应市场的不断变化的需求和使用场景，各类服务提供商不得不快速的迭代产品。反之，由于产品的过于快速的迭代，使用户需要不断的更新和下载应用，造成用户体验较差。通过对android虚拟机加载Class的机制研究实现动态加载，让用户不用重新安装APK就实现应用升级更新功能。 From the beginning of the 21st century, with the rapid development of mobile Internet, the num-ber of global Internet users increased rapidly. In order to meet the needs of different users in different scenarios, mobile applications continue to emerge; while its continuous improvement, people also have a dependence on mobile applications. Mobile applications have been fully integrated into the people’s eating, wearing, living, traveling and other aspects. So, in order to adapt to the ever-changing market demand and the use of scenarios, various service providers have to quickly iterative products. Conversely, because the product is too fast iteration, users need to constantly update and download applications, resulting in poor user experience. In order to enable users do not have to reinstall APK to achieve the application upgrade update function, you need to use dynamic loading technology in Android projects. In this paper, the dynamic loading technology of Android is studied.

Exception handling bug hazards in Android

Adequate handling of exceptions has proven difficult for many software engineers. Mobile app developers in particular, have to cope with compatibility, middleware, memory constraints, and battery restrictions. The goal of this paper is to obtain a thorough understanding of common exception handling bug hazards that app developers face. To that end, we first provide a detailed empirical study of over 6,000 Java exception stack traces we extracted from over 600 open source Android projects. Key insights from this study include common causes for system crashes, and common chains of wrappings between checked and unchecked exceptions. Furthermore, we provide a survey with 71 developers involved in at least one of the projects analyzed. The results corroborate the stack trace findings, and indicate that developers are unaware of frequently occurring undocumented exception handling behavior. Overall, the findings of our study call for tool support to help developers understand their own and third party exception handling and wrapping logic.

Learning to rank code examples for code search engines

Source code examples are used by developers to implement unfamiliar tasks by learning from existing solutions. To better support developers in finding existing solutions, code search engines are designed to locate and rank code examples relevant to user's queries. Essentially, a code search engine provides a ranking schema, which combines a set of ranking features to calculate the relevance between a query and candidate code examples. Consequently, the ranking schema places relevant code examples at the top of the result list. However, it is difficult to determine the configurations of the ranking schemas subjectively. In this paper, we propose a code example search approach that applies a machine learning technique to automatically train a ranking schema. We use the trained ranking schema to rank candidate code examples for new queries at run-time. We evaluate the ranking performance of our approach using a corpus of over 360,000 code snippets crawled from 586 open-source Android projects. The performance evaluation study shows that the learning-to-rank approach can effectively rank code examples, and outperform the existing ranking schemas by about 35.65 % and 48.42 % in terms of normalized discounted cumulative gain (NDCG) and expected reciprocal rank (ERR) measures respectively.

Blending an Android development course with software engineering concepts

The tremendous popularity of mobile computing and Android in particular has attracted millions of developers who see opportunities for building their own start-ups. As a consequence Computer Science students express an increasing interest into the related technology of Java development for Android applications. Android projects are complex by nature and relatively large software products while their development calls for the application of established software engineering practices and tools. However, most software engineering courses focus on `conventional' software development for desktop or web applications. In this paper we report on the design, implementation and assessment of a novel short course aiming at bridging the gap between software engineering and Android development. The goal is to demonstrate the need for applying software engineering principles on Android development as well as to emphasize that writing software for mobile devices should be regarded as an equally serious programming activity. The proposed course covers design principles, patterns, metrics, refactorings and collaborative software development. The course has been delivered to three groups of undergraduate and postgraduate students at two different institutes. The course has been evaluated: a) by performing a student satisfaction survey, b) through summative assessment of students' performance, c) by investigating whether the proposed course modified the students' career interests and d) by employing assessment by peers based on rubrics. The results indicate that such a short course is capable of increasing student's interest on Android development as well as their awareness of the importance of software engineering concepts on mobile application software development.