Enhancing Network Communication in Android: Transitioning from REST to GraphQL

In this presentation, we will explore different approaches for network communication in Android, starting with traditional RESTful APIs and progressing to GraphQL. We will discuss the pros and cons of each approach and provide practical guidance on implementing efficient and scalable network layers in Android apps. Through examples and real-world scenarios, you will gain insights into selecting the right approach for your app's specific needs.

Transcript

1. Optimizing Network Communication in Android: From REST to GraphQL
2. Who am I?
3. Who am I? Kemal Selim Tekinarslan Sr. Android Engineer Kotlin & Android. Travel Lover Paragliding is passion Links: /tekinarslan on Github /in/tekinarslan/ on LinkedIn
4. About HolidayPirates The HolidayPirates Group is one of the fastest-growing, free-to-use, travel search platforms and apps, providing users with the best value for money travel deals.
5. markets Our HolidayPirates.com UrlaubsPiraten.de VoyagesPirates.fr ViajerosPiratas.es VakantiePiraten.nl UrlaubsPiraten.at FerienPiraten.ch TravelPirates.com WakacjniPiraci.pl PiratinViaggio.it We are present in 10 different markets
6. 01 The Importance of Efficient Network Communication 02 REST API Overview 03 Introducing GraphQL 04 Challenges with REST 05 Why adopt GraphQL? Contents An overview of what I will present to you today
7. The Importance of Efficient Network Communication 01
8. Efficient Network Communication Battery Life Efficient network communication preserves device battery by minimizing data transmission, boosting the application's energy efficiency
9. Efficient Network Communication Scalability When network communication is optimized, applications improve scalability and performance, efficiently managing a higher user and data request load.
10. Efficient Network Communication Bandwidth Optimization Simplified communication optimizes network bandwidth usage, ensuring efficient data transfers while minimizing resource consumption.
11. Efficient Network Communication Support for Low-Connectivity Environments Optimized communication is crucial for users in areas with limited connectivity, enabling applications to function more reliably and provide essential services even under challenging network conditions.
12. Efficient Network Communication Improved User Experience Optimizing network communication ensures a seamless user experience with swift interactions and data loading, enhancing overall app enjoyment.
13. REST API Overview 02
14. REST, which stands for Representational State Transfer, is an architectural style for designing networked applications. It was introduced by Roy Fielding in his doctoral dissertation in 2000 REST and its key concepts
15. REST and its key concepts Uniform Interface RESTful services should have a uniform and consistent interface. This means that resources should be accessible through a consistent set of URLs and use standard HTTP methods.
16. REST and its key concepts Methods GET: Retrieve data from the server. POST: Create new resources on the server. PUT: Update existing resources on the server. DELETE: Delete resources on the server.
17. REST and its key concepts Stateless Communication REST is designed to be stateless, meaning that each request from a client to the server must contain all the necessary information to understand and fulfill the request. Servers do not store any client state between requests.
18. REST and its key concepts Scalability and Performance REST's statelessness and caching mechanisms contribute to improved scalability and performance of APIs, as resources can be distributed and cached effectively.
19. Shortly REST offers several advantages Simplicity Scalability Compatibility Caching Stateless Well-Defined Standards
20. Introducing GraphQL 03
21. GraphQL and its key concepts Types Scalar : Basic atomic types like Int, Float, String, Boolean, and ID. Object : Custom defined types that represent real-world objects like users, posts, comments, etc. Enum : A set of predefined values, like statuses, that a field can have. Input : Used in mutations to pass complex input data.
22. GraphQL and its key concepts Schema GraphQL starts with defining a schema that outlines the types of data that can be queried and the relationships between them. The schema is the contract between the client and the server, specifying what types of queries and mutations are available.
23. GraphQL Apollo
25. Queries Queries request data from servers, shaped by the client's needs, specifying desired fields and any filtering or sorting arguments. GraphQL and its key concepts
28. Mutations Mutations are similar to queries, but they are used to modify data on the server. They can perform actions like creating, updating, or deleting data. GraphQL and its key concepts
29. Challenges with REST 04
30. How GraphQL Overfetching and Underfetching: When using REST APIs, it's possible to receive more data than needed (overfetching) or not enough data (underfetching). This can impact performance and user experience. solves the challenges faced by REST
31. Overfetching and Underfetching: When using REST APIs, it's possible to receive more data than needed (overfetching) or not enough data (underfetching). This can impact performance and user experience. Overfetching and Underfetching GraphQL addresses overfetching and underfetching problems by enabling clients to request precisely tailored data, optimizing data retrieval through a specified response structure in the query language. How GraphQL solves the challenges faced by REST
32. Multiple Requests REST APIs often require multiple endpoints to retrieve different types of data, resulting in a multiplication of endpoints and increased complexity. How GraphQL solves the challenges faced by REST
33. Multiple Requests REST APIs often require multiple endpoints to retrieve different types of data, leading to a proliferation of endpoints and increased complexity. Multiple Requests GraphQL streamlines the API architecture by consolidating all queries into a single endpoint, minimizing the number of endpoints and simplifying network requests for clients. How GraphQL solves the challenges faced by REST
34. N+1 Query Problem In REST, fetching related data often requires multiple requests, leading to the N+1 query problem, where one initial request is followed by N additional requests to retrieve associated data. How GraphQL solves the challenges faced by REST
35. N+1 Query Problem In REST, fetching related data often requires multiple requests, leading to the N+1 query problem, where one initial request is followed by N additional requests to retrieve associated data. N+1 Query Problem GraphQL efficiently resolves this issue using 'resolver functions' that fetch data for each query field, enabling developers to optimize and batch data retrieval. How GraphQL solves the challenges faced by REST
36. Data Loading When you request data from a single REST endpoint, you usually receive the full dataset associated with that endpoint. In this case application screen will not load at low internet speeds. How GraphQL solves the challenges faced by REST
37. Data Loading When you request data from a single REST endpoint, you usually receive the full dataset associated with that endpoint. In this case application screen will not load at low internet speeds. Data Loading GraphQL empowers clients to perform partial data loading during the fetching process. How GraphQL solves the challenges faced by REST
38. Versioning REST APIs often require versioning to maintain backward compatibility, and changes to the API can result in breaking changes for clients. How GraphQL solves the challenges faced by REST
39. Versioning REST APIs often require versioning to maintain backward compatibility, and changes to the API can result in breaking changes for clients. Versioning GraphQL's strong type system and versionless schema make it easier to evolve APIs without introducing breaking changes. Clients can request the exact shape of data they expect. How GraphQL solves the challenges faced by REST
40. Post List
41. Why adopt GraphQL? 05
42. GraphQL is production-ready GraphQL is tried, tested, and proven to be stable for use in real-world applications. Its wide adoption by major companies attests to its readiness and reliability in production environments. GraphQL? Why adopt
43. Organizations using GraphQL GraphQL? Why adopt
44. Frontend Control over Data GraphQL empowers the client to request specific data fields, granting fine- grained control and reducing unnecessary data transmission. GraphQL? Why adopt
45. Real-time Capabilities GraphQL enables dynamic and interactive user experiences by supporting real-time updates through subscriptions. GraphQL? Why adopt
46. Federated Architecture GraphQL's federated approach enhances scalability and autonomy by enabling services to own and manage designated parts of the schema. GraphQL? Why adopt
47. Versioning and Evolution GraphQL provides a backward-compatible approach to schema changes, enabling smooth versioning and evolution of APIs without breaking existing clients. GraphQL? Why adopt
48. Single Endpoint, Multiple Sources GraphQL consolidates multiple data sources into a single endpoint, streamlining data retrieval and minimizing round-trip requests. GraphQL? Why adopt
49. Parallel Data Loading GraphQL allows for parallel data loading, enhancing performance by fetching related data concurrently. GraphQL? Why adopt
50. Strongly Typed Schema A Strongly Typed Schema in GraphQL enforces a defined structure for data queries, specifying the types and relationships allowed, ensuring consistency and predictability in data retrieval. GraphQL? Why adopt
51. Efficient Development Workflow 1 Self-Documenting APIs 2 Versionless Evolution 4 Collaboration and Frontend Independence 3 The schema is a powerful source of truth. 5 Elevating Developer Experience GraphQL? Why adopt
54. Additional data per session = 2KB Total additional data consumption = Additional data per session * Total number of sessions Total number of sessions = Active users (1 million) * Total number of sessions (5 times a day) Total number of sessions = 100,000,000 sessions Total additional data consumption = Additional data per session * Total number of sessions Total additional data consumption = 5KB * 100,000,000 sessions Total additional data consumption = 500,000,000 KB 500,000,000 KB ÷ 1,024 (KB in a MB) ÷ 1,024 (MB in a GB) ≈ 500 GB Network Traffic.
55. Sample Project on Github 06
56. github.com/tekinarslan Project : AppDevConWorkshopApp
57. Thank you