Android Networking and APIs

Android Networking

• Android Networking comprises the tools, techniques, and APIs provided by the Android platform for communication between an Android app and other devices or servers over a network.
• Networking enables apps to send and receive text, images, videos, and other resources over the internet or a local network
• It plays a crucial role in social media, messaging, e-commerce, and gaming apps.

Networking APIs

• HttpURLConnection is a low-level API for performing HTTP requests; it is flexible but requires more boilerplate code.
• OkHttp is a widely used third-party library facilitating efficient and easy HTTP operations.
• Retrofit is a high-level library built on top of OkHttp that simplifies API interactions by allowing developers to define endpoints as interfaces to make RESTful API calls.
• Volley is a Google-supported library for managing network operations, which is especially useful for caching and request queuing.

Protocols

• HTTP/HTTPS is the most common protocols for sending and receiving data over the web.
• WebSockets is used for real-time communication between the app and server, ideal for chat or live notifications.
• TCP/UDP are low-level protocols used for direct socket-based communication.

Data Parsing

• Data that is received from servers is often in JSON or XML format.
• Libraries like Gson, Moshi, or Android's built-in parsers help convert this data into usable objects.

Background Threads

• Network operations cannot run on the main thread because they can block the UI and lead to ANRs (Application Not Responding errors).
• APIs like AsyncTask, HandlerThread, or modern solutions such as Kotlin Coroutines and WorkManager ensure background execution.

Network Security

• TLS/SSL Certificates enable secure communication over HTTPS.
• Android provides XML-based configurations to enforce security rules, such as blocking cleartext traffic through Network Security Configuration.

Connectivity Management

• ConnectivityManager is used for monitoring the network state (Wi-Fi, Mobile Data, etc.) and responding to changes.
• Introduced in newer versions of Android, NetworkCallbacks provides more robust network change tracking.

Caching and Error Handling

• Libraries such as Retrofit and Volley provide built-in caching mechanisms to minimize redundant network requests and enable offline access.
• Handling issues like timeouts, no connectivity, or invalid responses is essential for building a robust networking layer.

Android and Web Connectivity

• Android and Web Connectivity refers to the mechanisms and tools to enable communication between Android devices and web services or platforms over a network.
• This communication is fundamental for apps to interact with remote servers, fetch, send data, and provide real-time functionalities.

RESTful APIs

• Android apps often connect to web services using REST APIs, which use standard HTTP methods like GET, POST, PUT, and DELETE.
• These APIs return data in JSON or XML format, parsed and utilized within the app.
• Common libraries for working with RESTful APIs in Android include Retrofit, OkHttp, and Volley.
  • Retrofit is a robust, high-level library.
  • OkHttp is a flexible library that is often used as a foundation for other libraries.
• Volley is designed specifically for managing network requests.

GraphQL APIs

• GraphQL APIs are a query language for APIs that allows clients to request specifically the data they need.
• Libraries, such as Apollo Android, facilitate the integration of GraphQL APIs into Android apps

WebSockets

• WebSockets is a protocol that is used for real-time, two-way communication between the app and the server.
• It is ideal for chat applications, live notifications, or streaming.
• Libraries like okhttp-ws or third-party services like Firebase can be used.

Firebase

• Firebase provides real-time database and cloud messaging services.
• It allows seamless connectivity between Android apps and the web using SDKs.
• Key features include data synchronization, analytics, and push notifications.

OAuth and Authentication

• Many apps integrate with web services like Google, Facebook, or custom APIs using OAuth for secure authentication.
• Android libraries like Google Sign-In SDK and Firebase Authentication simplify the process.

Web Content

• WebView is used to load and display web pages inside an app and is ideal for hybrid apps or rendering specific web content.
• Chrome Custom Tabs provide a lightweight way to display web content with browser-like features while maintaining app context.

Cloud Storage and IoT

• Android apps often interact with cloud storage systems such as Amazon S3, Google Cloud Storage, or Dropbox.
• APIs for these services allow uploading, retrieving, and managing files.
• Android apps may interact with IoT devices or embedded systems via MQTT or HTTP APIs provided by the device's firmware.

Push Notifications and File Handling

• Firebase Cloud Messaging (FCM) or OneSignal are used to send notifications from web servers to Android devices.
• Android apps may upload files to or download files from web servers with Retrofit supporting multipart requests for uploads; tools like WorkManager help handle long-running downloads.

Synchronous Communication

• Synchronous Communication denotes a tightly coupled manner of operation between sender and receiver, where one party waits for the other to complete its task before proceeding.
• The sender waits (or blocks) for the receiver to complete its task or provide a response.
• Tasks are performed one after the other in a linear order.
• Both the sender and receiver must be active simultaneously for real-time interaction.
  • Advantages: Simpler to implement, also easier to debug due to the predictable order.
  • Disadvantages: Inefficient for tasks involving long waits such as network calls or file I/O, can lead to unresponsive user interfaces in UI-based applications.

Asynchronous Communication

• Asynchronous Communication denotes that the sender and receiver operate independently
• Non-Blocking: The sender does not wait for the receiver; instead, the response is handled later (e.g., via callbacks, promises, or events).
• Concurrent Execution: Multiple tasks can run simultaneously or overlap in execution.
• Delayed Interaction: Responses may arrive at any time and are not necessarily in real-time.
  • Advantages: Improves application responsiveness, especially for tasks like network calls or file downloads as well as overall efficiency.
  • Disadvantages: Harder to debug due to concurrency issues, also more complex to implement due to the need for callbacks, error handling, and synchronization.

Use Cases

• Simple, short tasks, where blocking is acceptable (e.g., reading a small file), and where tasks must execute in strict order uses Synchronous Communication.
• For things such as network calls or database queries to prevent blocking the UI thread, real-time updates like chat apps or stock market trackers, and tasks that involve I/O operations, such as file uploads or downloads, Asynchronous is best.

Microservices in Android

• Microservices in Android refers to integrating an Android app with a backend that uses a microservices architecture.
• Android apps often interact with backend services to fetch and update data, authenticate users, or perform business logic.

Client-Server Model

• Android apps consume services from a microservices-based backend, and the backend is divided into several independent services (e.g., user authentication, payment processing, notifications), each handling specific functionality.
• Android apps communicate with microservices over the network through HTTP, HTTPS, or other protocols and use common tools and frameworks for making API requests, including Retrofit, OkHttp, and Volley.
  • GraphQL Clients: Apollo is used for interacting with GraphQL-based microservices like Apollo.

API Gateway and Real-Time Communication

• Android apps communicate with an API Gateway opposed to directly communicating with individual microservices.
• The API Gateway handles routing requests to the appropriate microservices, aggregates data, and applies cross-cutting concerns like authentication, rate limiting, and caching.
• Android apps use protocols like WebSockets or services like Firebase Realtime Database or AWS AppSync for real-time updates from microservices.

Authentication and Security

• Security measures include HTTPS for encrypted communication, secure token storage, and certificate pinning.
• Android apps usually authenticate with the backend via tokens, such as JSON Web Tokens (JWT) or OAuth tokens.

Asynchronous Operations:

• Kotlin Coroutines, RxJava, and WorkManager for long-running background tasks are commonly used in Android apps since microservices often involve multiple network calls.

Benefits of Microservices

• Backend services can scale independently based on app demand such as user authentication, which can scale separately from less-used services to improve scalability.
• If one service fails, fault isolation prevents impact on other parts of the system
• Independent backend teams can make updates or replace services without disrupting the entire system, for faster development with ensured continuous availability for the Android app.
• Modular Updates can be requested by Android apps from specific services without depending on a monolithic backend.
• Each microservice can use optimal tech for overall system efficiency through technology flexibility:

Challenges of Microservices

• Since there is a microservices architecture, the application may require making several network requests, which increases latency and data usage.
• Troubleshooting becomes difficult, as failures in one or more microservices can makes it difficult to display handled errors.
• A lot of API consumption from multiple microservices requires careful management of API versions and changes requiring lots of consuming APIs.
• Complexity with data aggregation is increased since often, data needs to come from multiple services, which is usually handled by the API Gateway or specific aggregating services.

Best Practices

• A unified API Gateway should be implemented so the app should communicates with it rather than multiple microservices to reduce the complexity of managing multiple endpoints in the app.
• Batching, caching, and pagination also reduce complexity
• Libraries such as Retrofit provide built-in support for caching.
• robust error-handling strategies should be implemented for network failures, timeouts, and service unavailability
• Tools like Circuit Breakers can assist with the backend to gracefully handle service failures such as Netflix Hystrix.
• real-time communication tools such as as WebSockets, Firebase Realtime Database used be used for live updates to be integrated with microservices
• Enable HTTPS.
• Always enable OAuth or token-based authentication
• Use a WorkManager or JobScheduler.
• Ensure usage is synchronised
• Integrate tools to monitor API performance and usage such as Firebase Performance Monitoring.

Containers

• Containers refer to technologies such as Docker, Kubernetes, or similar tools to manage, deploy, or test Android applications or environments.
• They package an application and its dependencies together, allowing applications to run consistently across various environments regardless of underlying hardware or operating systems.

Uses for Containers

• Container images comprise tools such as Android Studio, Gradle, and SDKs, ensuring consistent development environments across teams, in the process of building android applications.
• Running Emulators: Containers host Android emulators, enabling developers to test apps without requiring direct access to physical devices or local installation of emulators.
• They also play a vital role in continuous integration and continuous deployment (CI/CD) pipelines for Android applications.

Docker

• Pre-configured Docker images offer portable, consistent environments for building and testing, and also helps easily share development setups with team members enabling Docker for Android Development.
• Genymotion Cloud is a cloud-based Android emulator that runs in containers, enabling developers to test apps without local installations.
• Kubernetes orchestrates backend services, ensuring scalability and resilience especially useful For Android apps who interact with the backend.
• Android Container (by Budtmo) allows developers to run Android emulators inside Docker containers, useful for automated UI testing and Android Emulator in Containers generally.

What is JSON?

• JSON (JavaScript Object Notation) is a lightweight, text-based data format used to represent structured data.
• It is easy for humans to read and write, and simple for machines to parse and generate and commonly used for data exchange between web applications and servers.

KeyFeatures

• Human-Readable: JSON data is written in plain text, making it easy to read and understand.
• Language-Independent: Although it originates from JavaScript, JSON is supported by most programming languages.
• Lightweight: JSON minimizes data structure representation.

JSON Data

• There are Key-value pairs (like a dictionary in Python) or an ordered list of values (like an array).
• Basic Syntax involves Objects: Enclosed in curly braces {}, and contains key-value pairs Keys are strings in double quotes, and values have various primitive types (strings, numbers, arrays, booleans, objects, null)

JSON Arrays

• Contain list of delimited values
• Enclosed in square brackets []

Advantages of JSON

• Widely used via RESTful APIs with most programming languages
• It can be exchanged between a client and a server as well as configuration and NoSQL databases such as MongoDB.

Why Use JSON

• JSON integrates seamlessly with JavaScript, making it ideal for front-end development, supported by various backend systems allowing for smooth communication across systems.
• JSON can represent complex, hierarchical data through nested objects and arrays and is versatile for applications, especially relative to XML, due to not being code verbose.
• JSON is the standard format for modern web services and APIs, Universally.
• Since JSON parsing is faster for web apps, this also reduces bandwidth and helps modern databases, including NoSQL, including MongoDB and Couch DB.

Syntax Rules

• Data is arranged between key-value pairs, where Keys must be strings in between ""
• Values can be strings, numbers, objects, arrays, booleans, and null
• Objects are {} and arrays []
• Commas separate elements with no trailing commas
• Objects and Arrays can be nested and comments are not allowed

JSON GET

• Often refers to using JSON as a data format when sending or receiving data in an HTTP GET request, the server commonly uses JSON as the format for the server's response, and Parameters are typically sent as query strings in the URL/

Structure of a JSON GET Request

• The client requests from http with the relevant parameters like a host, the method name, etc.
• The server responds with JSON formatted data.

JSON POST

• refers to sending data to a server using an HTTP POST request, with JSON as the data payload.
• Used in APIs and web applications to create or update resources on a server.

JSON POST Purpose

• To upload or new existing resouces

JSON POST Structure

Headers must be of the correct content type

• http
• The server responds with JSON formatted data, includes Status Code - e.g., 201 Created, 200 OK and JSON payload confirming the action or returning additional data.

JSON PUT

• Is often used to update an existing resource or create a resource if it doesn't exist and formatted with JSON.

JSON PUT Purpose

• Update an existing resource or create a new one.

JSON PUT structure

• The URL must indicate the resource. and data must be full
• and the status code could be 200 if existing, or 201 if creating new.
• Is mostly the same as post.

JSON DELETE

• method refers to using HTTP DELETE with RESTful APIs to remove specific resource

JSON DELETE Purpose

• Deletes a specific resource identified by its URL or Soft Deletion.
• Some APIs use a DELETE request to mark a resource as inactive instead of permanently removing it.

Components of JSON DELETE Request and Response

• Headers optionally Accept: application/json indicate response format
• Can include Request Body not commonly used but possible for batch deletions or additional context.
• Commonly uses a 200 code for OK, 204 no content was available to be deleted

Common JSON Response Codes

• 200 OK
• The was success
• 201 the request was post ok as well
• 400 malformed
• 404 not found
• 500 Internal server error

JSON Request

• Sent to by sending JSON-formatted data, create, read, update and delete
• POST, PUT, GET, DELETE

JSON Response

• Contains the status, the outcome and response

JSON and HTTP

JSON and HTTP make up a RESTful API.