In this section, the context in which Hybrid \ac{OSN} is located is first considered, and then a breakdown into the individual components is carried out. Furthermore, the function of the respective blocks is described in more detail. Finally, the function of individual components in interaction is explained using the examples of displaying the home timeline and posting a new tweet.

\subsection{Scope and Context}
\label{sec:scope-and-context}
Figure \ref{fig:building-block-view} shows a black box view of which other systems Hybrid \ac{OSN} communicates with via interfaces. The systems are:

\begin{itemize}
	\item Twitter \ac{API}
	\item GUN
	\item \ac{IPFS} via Infura
	\item User 
\end{itemize}

Infura\footnote{https://infura.io/} is a service that provides access to Ethereum and \ac{IPFS} via a simple interface. Communication with the \ac{API} happens using \ac{HTTP} requests. The connection of \ac{IPFS} in Hybrid \ac{OSN} can thus be carried out in a simple way. The use of an additional system entails an extra risk typically. However, there is a JavaScript client for \ac{IPFS}, which can be integrated into Hybrid \ac{OSN} and thus the dependency on Infura would be omitted. For the creation of the prototype, the decision was made to use Infura for reasons of simplicity. Infura can be used for \ac{IPFS} free of charge and without registration.

\begin{figure}[h!]
	\centering
	\includegraphics[width=1.0\textwidth]{building-block-view}
	\caption{.}
	\label{fig:building-block-view}
\end{figure}

\subsection{White Box View}
\label{sec:white-box}

The Ionic framework uses Angular in the core. Accordingly, the Hybrid \ac{OSN} app is in principle an Angular application. The essential building blocks are components, pages, and providers. In the following, these components are described in detail and examples are given of where they are used in Hybrid \ac{OSN}.

\subsubsection{Providers}
\label{providers}
Data access is performed using providers (known as services in Angular). For the external services (Twitter \ac{API}, \ac{P2P} database, \ac{P2P} storage), there is one provider each to handle the communication. Besides, providers are used as helper classes providing specific functionality that is used several times. This functionality includes, for example, encryption and decryption and the compilation of aggregated timelines. Providers are injected into components using the constructor. Table \ref{tab:providers} lists all providers used in Hybrid OSN and their functional descriptions.

\begin{table}[h!]
	\begin{tabularx}{\textwidth}{|l|X|}
		\hline
		\textbf{Provider}      & \textbf{Purpose}                                                                                  \\ \hline
		Auth                   & Manage and perform authentication against the Twitter \ac{API}. Responsible for login and logout. \\ \hline
		Crypto                 & Provides methods for encryption, decryption, and key generation                                   \\ \hline
		Feed                   & Aggregation of private (\ac{P2P}) and public (Twitter) tweets to compose a chronological timeline \\ \hline
		\ac{P2P}-Database-Gun  & Interface for data exchange with GUN                                                              \\ \hline
		\ac{P2P}-Storage-IPFS  & Interface for data exchange with \ac{IPFS} via Infura                                             \\ \hline
		Twitter-API            & Interface to use the Twitter \ac{API} using the Twit package                                      \\ \hline
	\end{tabularx}
	\caption{Providers used in the Hybrid \ac{OSN} app in alphabetical order with their purpose.}
	\label{tab:providers}
\end{table}

\subsubsection{Components}
\label{sec:components}
Components are the basic building blocks of a user interface. Figure \ref{fig:component-example} shows an example of the representation of a tweet in Hybrid \ac{OSN} using various components. A component consists of an \ac{HTML} template, \ac{CSS} styling, and JavaScript logic, whereby the logic is typically limited to a minimum. Components can be used as elements in other components or pages. A component receives the data it is supposed to visualize. Furthermore, components can process events or return them to parent components for handling.

\begin{figure}[h!]
	\centering
	\includegraphics[width=1.0\textwidth]{component-example}
	\caption{Composition of the tweet component from three other components. Several tweet components are in turn combined to form a feed component.}
	\label{fig:component-example}
\end{figure}

\subsubsection{Pages}
\label{pages}
Pages are specialized components that are used as a holistic view. A page is made up of several other components. The data to be displayed is loaded using providers. To be able to navigate between the individual pages within the app, the model of a stack is used (implemented by the NavController). The currently visible page is at the top of the stack. When another page is called, it is pushed onto the stack. Pressing \enquote{Back} removes the top page from the stack and displays the page below it.

Table \ref{tab:pages} lists all pages and their purpose. When the app is opened, it checks whether the user is already logged in. Depending on this, the user starts with the Login Page or the Home Page.

\begin{table}[h!]
	\begin{tabularx}{\textwidth}{|l|X|}
		\hline
		\textbf{Page}                 & \textbf{Purpose}                                                                                                                         \\ \hline
		About                         & Information about the app, which can be accessed via the login page to get basic information about the app before logging in             \\ \hline
		Home                          & Chronological view of the latest tweets from Twitter and the private network                                                             \\ \hline
		Login                         & Authentication against Twitter to use the Twitter \ac{API}                                                                               \\ \hline
		Profile                       & Presentation of a user profile consisting of the user data (profile picture, brief description, location, website) and the user timeline \\ \hline
		Search                        & Container page for searching for tweets and users, where tweets are also divided into popular and recent (see Search-Results-Tweets-Tab) \\ \hline
		Search-Results-Tweets-Popular & Search results of currently popular tweets for a given keyword                                                                           \\ \hline
		Search-Results-Tweets-Recent  & Search results of recent tweets for a given keyword                                                                                      \\ \hline
		Search-Results-Tweets-Tab     & Container page for the search results for tweets (recent and popular) in tabs                                                            \\ \hline
		Search-Results-Users          & Search results of users for a given keyword                                                                                              \\ \hline
		Settings                      & Configuration of keywords that trigger the private mode and settings regarding encryption                                                \\ \hline
		Write-Tweet                   & Form for writing a tweet                                                                                                                 \\ \hline
	\end{tabularx}
	\caption{Pages used in the Hybrid \ac{OSN} app in alphabetical order with their purpose.}
	\label{tab:pages}
\end{table}

\subsubsection{Local Storage}
\label{sec:local-storage}
As the name suggests, this is a local storage that is accessible by the app. With Hybrid \ac{OSN}, this memory is used to store essential information for usage. These include the Twitter user id, the two tokens for accessing the Twitter \ac{API}, the keywords that trigger the private mode, and private and public keys for encryption. Log out completely deletes the local storage.
