Screenloop

screenloop

Implementing a robust authentication system is crucial for mobile applications. In this guide, I'll walk you through setting up Auth0 authentication with Expo Router, creating a seamless and secure user experience. Prerequisites Before starting, ensure you have: An Expo project using Expo Router
An Auth0 account with a configured application
Basic understanding of React Native and TypeScript An Expo project using Expo Router An Auth0 account with a configured application Basic understanding of React Native and TypeScript Step 1: Install Required Dependencies First, install the Auth0 React Native SDK: yarn add react-native-auth0 yarn add react-native-auth0 Step 2: Configure Auth0 Create an auth0.config.js file in your project root: auth0.config.js const config = {
  clientId: "YOUR_AUTH0_CLIENT_ID",
  domain: "YOUR_AUTH0_DOMAIN",
}

export default config const config = {
  clientId: "YOUR_AUTH0_CLIENT_ID",
  domain: "YOUR_AUTH0_DOMAIN",
}

export default config Replace the placeholders with your actual Auth0 credentials. Step 3: Create an Authentication Context The authentication context will manage the auth state throughout your app. Create a file called useAuth.tsx in your hooks directory: useAuth.tsx import { createContext, useContext, useEffect, useState } from "react"
import { useAuth0 } from "react-native-auth0"
import { router, useSegments, useRootNavigationState } from "expo-router"

// Define the shape of our auth context
type AuthContextType = {
  signIn: () => Promise<void>
  signOut: () => Promise<void>
  isAuthenticated: boolean
  isLoading: boolean
  user: any
  error: Error | null
}

// Create the context with a default value
const AuthContext = createContext<AuthContextType | null>(null)

// Provider component that wraps the app
export function AuthProvider({ children }: { children: React.ReactNode }) {
  const { authorize, clearSession, user, error, getCredentials, isLoading } =
    useAuth0()
  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false)
  
  const segments = useSegments()
  const navigationState = useRootNavigationState()

  // Check if the user is authenticated and redirect accordingly
  useEffect(() => {
    if (!navigationState?.key) return
    
    const inAuthGroup = segments[0] === "(auth)"
    
    if (isAuthenticated && inAuthGroup) {
      // Redirect authenticated users from auth screens to the main app
      router.replace("/(tabs)")
    } else if (!isAuthenticated && !inAuthGroup) {
      // Redirect unauthenticated users to the login screen
      router.replace("/(auth)/login")
    }
  }, [isAuthenticated, segments, navigationState?.key])

  // Update authentication state when user changes
  useEffect(() => {
    setIsAuthenticated(!!user)
  }, [user])

  // Sign in function
  const signIn = async () => {
    try {
      await authorize()
      const credentials = await getCredentials()
      console.log("Auth credentials:", credentials)
      setIsAuthenticated(true)
    } catch (e) {
      console.error("Login error:", e)
    }
  }

  // Sign out function
  const signOut = async () => {
    try {
      await clearSession()
      setIsAuthenticated(false)
    } catch (e) {
      console.error("Logout error:", e)
    }
  }

  return (
    <AuthContext.Provider
      value={{
        signIn,
        signOut,
        isAuthenticated,
        isLoading,
        user,
        error,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

// Custom hook to use the auth context
export function useAuth() {
  const context = useContext(AuthContext)
  if (!context) {
    throw new Error("useAuth must be used within an AuthProvider")
  }
  return context
} import { createContext, useContext, useEffect, useState } from "react"
import { useAuth0 } from "react-native-auth0"
import { router, useSegments, useRootNavigationState } from "expo-router"

// Define the shape of our auth context
type AuthContextType = {
  signIn: () => Promise<void>
  signOut: () => Promise<void>
  isAuthenticated: boolean
  isLoading: boolean
  user: any
  error: Error | null
}

// Create the context with a default value
const AuthContext = createContext<AuthContextType | null>(null)

// Provider component that wraps the app
export function AuthProvider({ children }: { children: React.ReactNode }) {
  const { authorize, clearSession, user, error, getCredentials, isLoading } =
    useAuth0()
  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false)
  
  const segments = useSegments()
  const navigationState = useRootNavigationState()

  // Check if the user is authenticated and redirect accordingly
  useEffect(() => {
    if (!navigationState?.key) return
    
    const inAuthGroup = segments[0] === "(auth)"
    
    if (isAuthenticated && inAuthGroup) {
      // Redirect authenticated users from auth screens to the main app
      router.replace("/(tabs)")
    } else if (!isAuthenticated && !inAuthGroup) {
      // Redirect unauthenticated users to the login screen
      router.replace("/(auth)/login")
    }
  }, [isAuthenticated, segments, navigationState?.key])

  // Update authentication state when user changes
  useEffect(() => {
    setIsAuthenticated(!!user)
  }, [user])

  // Sign in function
  const signIn = async () => {
    try {
      await authorize()
      const credentials = await getCredentials()
      console.log("Auth credentials:", credentials)
      setIsAuthenticated(true)
    } catch (e) {
      console.error("Login error:", e)
    }
  }

  // Sign out function
  const signOut = async () => {
    try {
      await clearSession()
      setIsAuthenticated(false)
    } catch (e) {
      console.error("Logout error:", e)
    }
  }

  return (
    <AuthContext.Provider
      value={{
        signIn,
        signOut,
        isAuthenticated,
        isLoading,
        user,
        error,
      }}
    >
      {children}
    </AuthContext.Provider>
  )
}

// Custom hook to use the auth context
export function useAuth() {
  const context = useContext(AuthContext)
  if (!context) {
    throw new Error("useAuth must be used within an AuthProvider")
  }
  return context
} This context provides: Authentication state management
Sign-in and sign-out functions
Automatic redirection based on authentication status
Access to user information and error states Authentication state management Sign-in and sign-out functions Automatic redirection based on authentication status Access to user information and error states Step 4: Set Up the Root Layout Update your app/_layout.tsx file to include the Auth0Provider and AuthProvider: app/_layout.tsx import { Auth0Provider } from "react-native-auth0"
import config from "@/auth0.config"
import { AuthProvider } from "@/hooks/useAuth"
// Other imports...

export default function RootLayout() {
  // Other code...

  return (
    <Auth0Provider domain={config.domain} clientId={config.clientId}>
      <AuthProvider>
        <ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
          <Stack>
            <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
            <Stack.Screen name="(auth)" options={{ headerShown: false }} />
            <Stack.Screen name="+not-found" />
          </Stack>
          <StatusBar style={colorScheme === "dark" ? "light" : "dark"} />
        </ThemeProvider>
      </AuthProvider>
    </Auth0Provider>
  )
} import { Auth0Provider } from "react-native-auth0"
import config from "@/auth0.config"
import { AuthProvider } from "@/hooks/useAuth"
// Other imports...

export default function RootLayout() {
  // Other code...

  return (
    <Auth0Provider domain={config.domain} clientId={config.clientId}>
      <AuthProvider>
        <ThemeProvider value={colorScheme === "dark" ? DarkTheme : DefaultTheme}>
          <Stack>
            <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
            <Stack.Screen name="(auth)" options={{ headerShown: false }} />
            <Stack.Screen name="+not-found" />
          </Stack>
          <StatusBar style={colorScheme === "dark" ? "light" : "dark"} />
        </ThemeProvider>
      </AuthProvider>
    </Auth0Provider>
  )
} Step 5: Create the Authentication Group Expo Router uses directory-based routing. Create an (auth) directory in your app folder with a layout file: (auth) // app/(auth)/_layout.tsx
import { Stack } from "expo-router"

export default function AuthLayout() {
  return (
    <Stack screenOptions={{ headerShown: false }}>
      <Stack.Screen name="login" />
    </Stack>
  )
} // app/(auth)/_layout.tsx
import { Stack } from "expo-router"

export default function AuthLayout() {
  return (
    <Stack screenOptions={{ headerShown: false }}>
      <Stack.Screen name="login" />
    </Stack>
  )
} Step 6: Create the Login Screen Create a login screen in app/(auth)/login.tsx: app/(auth)/login.tsx import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  ActivityIndicator,
} from "react-native"

export default function LoginScreen() {
  const { signIn, isLoading, error } = useAuth()

  return (
    <View style={styles.container}>
      <View style={styles.content}>
        <ThemedText style={styles.title}>Welcome to Your App</ThemedText>
        <ThemedText style={styles.subtitle}>Sign in to continue</ThemedText>

        <TouchableOpacity
          style={styles.button}
          onPress={signIn}
          disabled={isLoading}
        >
          {isLoading ? (
            <ActivityIndicator color="#fff" />
          ) : (
            <ThemedText style={styles.buttonText}>Sign In</ThemedText>
          )}
        </TouchableOpacity>

        {error && (
          <ThemedText style={styles.errorText}>{error.message}</ThemedText>
        )}
      </View>
    </View>
  )
}

// Styles... import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  ActivityIndicator,
} from "react-native"

export default function LoginScreen() {
  const { signIn, isLoading, error } = useAuth()

  return (
    <View style={styles.container}>
      <View style={styles.content}>
        <ThemedText style={styles.title}>Welcome to Your App</ThemedText>
        <ThemedText style={styles.subtitle}>Sign in to continue</ThemedText>

        <TouchableOpacity
          style={styles.button}
          onPress={signIn}
          disabled={isLoading}
        >
          {isLoading ? (
            <ActivityIndicator color="#fff" />
          ) : (
            <ThemedText style={styles.buttonText}>Sign In</ThemedText>
          )}
        </TouchableOpacity>

        {error && (
          <ThemedText style={styles.errorText}>{error.message}</ThemedText>
        )}
      </View>
    </View>
  )
}

// Styles... Step 7: Create a Profile Screen Add a profile screen to display user information and provide a logout option: // app/(tabs)/profile.tsx
import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  Image,
  ScrollView,
} from "react-native"

export default function ProfileScreen() {
  const { user, signOut, isLoading } = useAuth()

  return (
    <ScrollView style={styles.container}>
      <View style={styles.header}>
        {user?.picture ? (
          <Image source={{ uri: user.picture }} style={styles.avatar} />
        ) : (
          <View style={styles.avatarPlaceholder}>
            <ThemedText style={styles.avatarText}>
              {user?.name?.charAt(0) || user?.email?.charAt(0) || "?"}
            </ThemedText>
          </View>
        )}

        <ThemedText style={styles.name}>{user?.name || "User"}</ThemedText>
        <ThemedText style={styles.email}>{user?.email || ""}</ThemedText>
      </View>

      {/* User information display */}
      
      <View style={styles.actions}>
        <TouchableOpacity
          style={styles.logoutButton}
          onPress={signOut}
          disabled={isLoading}
        >
          <ThemedText style={styles.logoutText}>Sign Out</ThemedText>
        </TouchableOpacity>
      </View>
    </ScrollView>
  )
}

// Styles... // app/(tabs)/profile.tsx
import { ThemedText } from "@/components/ThemedText"
import { useAuth } from "@/hooks/useAuth"
import {
  StyleSheet,
  View,
  TouchableOpacity,
  Image,
  ScrollView,
} from "react-native"

export default function ProfileScreen() {
  const { user, signOut, isLoading } = useAuth()

  return (
    <ScrollView style={styles.container}>
      <View style={styles.header}>
        {user?.picture ? (
          <Image source={{ uri: user.picture }} style={styles.avatar} />
        ) : (
          <View style={styles.avatarPlaceholder}>
            <ThemedText style={styles.avatarText}>
              {user?.name?.charAt(0) || user?.email?.charAt(0) || "?"}
            </ThemedText>
          </View>
        )}

        <ThemedText style={styles.name}>{user?.name || "User"}</ThemedText>
        <ThemedText style={styles.email}>{user?.email || ""}</ThemedText>
      </View>

      {/* User information display */}
      
      <View style={styles.actions}>
        <TouchableOpacity
          style={styles.logoutButton}
          onPress={signOut}
          disabled={isLoading}
        >
          <ThemedText style={styles.logoutText}>Sign Out</ThemedText>
        </TouchableOpacity>
      </View>
    </ScrollView>
  )
}

// Styles... Step 8: Update the Tabs Layout Ensure your tabs layout includes the profile tab and checks authentication: // app/(tabs)/_layout.tsx
import { useAuth } from "@/hooks/useAuth"
// Other imports...

export default function TabLayout() {
  const { isAuthenticated } = useAuth()

  // Redirect to login if not authenticated
  React.useEffect(() => {
    if (!isAuthenticated) {
      // The AuthProvider will handle the redirect
    }
  }, [isAuthenticated])

  return (
    <Tabs
      screenOptions={{
        // Tab options...
      }}
    >
      {/* Other tabs */}
      <Tabs.Screen
        name="profile"
        options={{
          title: "Profile",
          tabBarIcon: ({ color }) => (
            <IconSymbol size={28} name="person.fill" color={color} />
          ),
        }}
      />
    </Tabs>
  )
} // app/(tabs)/_layout.tsx
import { useAuth } from "@/hooks/useAuth"
// Other imports...

export default function TabLayout() {
  const { isAuthenticated } = useAuth()

  // Redirect to login if not authenticated
  React.useEffect(() => {
    if (!isAuthenticated) {
      // The AuthProvider will handle the redirect
    }
  }, [isAuthenticated])

  return (
    <Tabs
      screenOptions={{
        // Tab options...
      }}
    >
      {/* Other tabs */}
      <Tabs.Screen
        name="profile"
        options={{
          title: "Profile",
          tabBarIcon: ({ color }) => (
            <IconSymbol size={28} name="person.fill" color={color} />
          ),
        }}
      />
    </Tabs>
  )
} Step 9: Create a Root Redirect Finally, create a root index file to handle initial routing: // app/index.tsx
import { Redirect } from "expo-router"
import { useAuth } from "@/hooks/useAuth"

export default function Index() {
  const { isAuthenticated, isLoading } = useAuth()
  
  // While checking authentication status, don't redirect yet
  if (isLoading) {
    return null
  }
  
  // Redirect based on authentication status
  return isAuthenticated ? (
    <Redirect href="/(tabs)" />
  ) : (
    <Redirect href="/(auth)/login" />
  )
} // app/index.tsx
import { Redirect } from "expo-router"
import { useAuth } from "@/hooks/useAuth"

export default function Index() {
  const { isAuthenticated, isLoading } = useAuth()
  
  // While checking authentication status, don't redirect yet
  if (isLoading) {
    return null
  }
  
  // Redirect based on authentication status
  return isAuthenticated ? (
    <Redirect href="/(tabs)" />
  ) : (
    <Redirect href="/(auth)/login" />
  )
} How It Works Initial Load: When the app starts, it checks the authentication status.
Authentication Flow:

Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality


Protected Routes: The AuthProvider automatically protects routes by redirecting unauthenticated users to the login screen. Initial Load: When the app starts, it checks the authentication status. Initial Load Authentication Flow:

Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality Authentication Flow Unauthenticated users are directed to the login screen
After successful login, users are redirected to the main app
The profile screen displays user information and provides logout functionality Unauthenticated users are directed to the login screen After successful login, users are redirected to the main app The profile screen displays user information and provides logout functionality Protected Routes: The AuthProvider automatically protects routes by redirecting unauthenticated users to the login screen. Protected Routes Benefits of This Approach Clean Separation: Authentication logic is isolated in a dedicated context
Route Protection: Automatic redirection based on authentication status
Reusable Authentication: The useAuth hook can be used throughout the app
Seamless UX: Users are directed to the appropriate screens based on their authentication status Clean Separation: Authentication logic is isolated in a dedicated context Clean Separation Route Protection: Automatic redirection based on authentication status Route Protection Reusable Authentication: The useAuth hook can be used throughout the app Reusable Authentication Seamless UX: Users are directed to the appropriate screens based on their authentication status Seamless UX Conclusion Setting up Auth0 with Expo Router provides a robust authentication system for your mobile application. This approach leverages Expo Router's group-based routing to create a clean separation between authenticated and unauthenticated content, while the authentication context manages the state and provides a consistent interface for authentication operations. By following this guide, you've implemented a complete authentication flow that handles login, logout, and protected routes in a maintainable and scalable way.

Setting Up Auth0 Authentication with Expo Router: A Complete Guide

How to work with Koin Scopes in Jetpack Compose Navigation

Superset uses and React Testing Library ( ) to write unit and integration tests. In the past we used , but now that we're currently converting all of our class components to functional components, Enzyme cannot support our testing needs. Since RTL is better for testing functional components, we're converting all of our test files to RTL. This can be quite a learning curve - I've gone through a lot of the process so I'd like to share what I've learned so far. Jest RTL Enzyme First and foremost: We have a document that outlines all the code styles we adhere to in our tests. Please use this document as a reference when writing your tests. Testing Guidelines and Best Practices The main thing you want to keep in mind is the different approaches each testing library uses in testing: It tests things in the "back" of the code that the user never sees, such as the props of a component. Enzyme is code-focused testing. All of your tests will rely on things the user can see and do. RTL is user-focused testing. For example: If there were an Enzyme test that checks the props of a component, you would look for where those props show visually on the component and capture it with RTL. Except for certain things like API mocking, Superset uses fetch-mock for that. , if you'd like to learn more about how to mock API calls in RTL. You can also look for other already-existing instances of fetch-mock in the codebase to see how it's used in Superset. Here's a link to the docs The test environment in Superset is getting healthier and easier to work with by the day, and I hope this will inspire you to help contribute to the cause! To wrap this up, I would like to leave you with some good RTL/testing resources: In your tests, use these commands to help with debugging: screen.debug() This will show you the rendered component in the console when you run the test. You can pass in a captured element if you want to see just that element instead of the whole rendered component. screen.logTestingPlaygroundURL() This will give you a link in the console when you run your test. Click this link and it will open an instance of the testing playground displaying your rendered component (or a captured element passed into the function) in the browser. for an example of what that looks like, this is a really cool feature 😁 It would look like this in the code: Check out this link const button = screen.getByRole('button');
screen.debug(button);
screen.logTestingPlaygroundURL(button); I converted 11 files in , feel free to use it as a reference for conversions this pull request The RTL docs have a good guide for converting from Enzyme RTL cheatsheet Jest matchers jest-dom matchers Superset has a very handy for RTL with supercharged functionality for our specific needs. helper file Originally posted . here Lead image source.

Testing Apache Superset: Migrating from Enzyme to RTL for Improved Testing

The essence of the pattern is that it creates a centralized bus through which components can send and receive messages (events). The bus acts as a mediator between the components, and they can exchange messages without the need for explicit coupling with each other. Hello everyone, my name is Dmitrii Ivashchenko, and I’m a Software Engineer at MY.GAMES. In this article, we’ll talk about an enum-based event bus in Unity, which we’ll get to in just a moment. Back to the event bus pattern itself, there are several ways to implement this, but the general idea remains the same: components send messages (events) to the bus, and other components subscribe to these events and receive them. There are two main methods to implement an event system: and : Subscribe Raise // At the point where the event occurs, we call Raise
// with the event type and data
EventBus.Raise(some_event_type, arguments);

// In the handler, we subscribe to a specific type
// of events and call the OnSomeEventRaised method
EventBus.Subscribe(some_event_type, OnSomeEventRaised); Often the event type is set as a string, but there are also implementations where a class for the passed data is used as the event type: public struct BuyEvent 
{
    public int ItedId;
}

// Raising a new event
EventBus.Raise<BuyEvent>(new BuyEvent{ ItemId = 1 });

// Subscription to event
EventBus.Subscribe<BuyEvent>(OnPlayerBuy); There are also more interesting implementations where interfaces are used for subscription. The event bus can be shared across the entire code, but there may also be separate buses that differ in purpose and method of message delivery. Another interesting way to implement EventBus is Enum-based. Why enums? Using enums as event types has several advantages: Improved code readability Low overhead for Enum processing Code autocompletion in IDE, with ease of adding new types Eliminated possibility of incorrect spelling, which is the case when using strings It adds the possibility of adding extension methods to extend functionality To more easily illustrate the main principle, some details have been omitted in the code examples below. We’ll also be using the class from the library to transmit events. Instead of UniRx, any other means of storing message handlers could also be used, such as C# delegates and events. ReactiveCommand UniRx . The complete source code is available on GitHub Using an Enum as a Event Bus One way to view an is as a type of data bus, with its elements representing concrete types of events delivered by this bus: Enum // Event bus for user interface-generated events
public enum UiEvent
{
    // Event on clicking on the "buy" button 
    BuyButtonClicked,

		// Event on opening an in-game window
		ScreenOpened,

		// Event on completing the tutorial
		TutorialFinished,

    ...
} Using C# extension methods, we can add methods for sending and subscribing to events to this enum: public static class UiEventExtensions
{
    // Declare a static readonly ReactiveCommand of type UiEvent
    private static readonly ReactiveCommand<UiEvent> 
        _uiEventCommand = new ReactiveCommand<UiEvent>();
    
    // Extension method to raise a UiEvent
    public static void Raise(this UiEvent evnt)
    {
        // Execute the ReactiveCommand with the UiEvent
        _uiEventCommand.Execute(evnt);
    }
    
    // Extension method to subscribe to a UiEvent
    public static IDisposable Subscribe(this UiEvent evntType, Action action)
    {
        // Return a subscription to the ReactiveCommand, 
        // filtered by the UiEvent type
        return _uiEventCommand.Where(evnt => evnt == evntType)
                              .Subscribe(evnt => action());
    }
} Now, we can send and receive events in the game logic like so: // Raise the BuyButtonClicked event
**UiEvent.BuyButtonClicked.Raise();**

// Subscribe to the BuyButtonClicked event
var disposable = **UiEvent.BuyButtonClicked.Subscribe**(OnBuyButtonClicked);

// ...

// Unsubscribe from the event
disposable.Dispose(); To pass parameters together with an event, we’ll need an additional class that will store the event type and data. Example implementation: // This class is used to store information about a UI event
public class UiEventParam
{
    // The type of the UI event
    public UiEvent Type { get; }

    // Constructor that sets the type of the UI event
    protected UiEventParam(UiEvent type) => Type = type;

    // Get the data associated with the UI event
    public T Get<T>() => ((UiEventParam<T>) this).Data;
}

// This class is used to store data associated with a UI event
public class UiEventParam<T> : UiEventParam
{
    // The data associated with the UI event
    public readonly T Data;

    // Constructor that sets the type and data of the UI event
    public UiEventParam(UiEvent type, T data) : base(type) => Data = data;
}

public static class UiEventExtensions
{
    // Declare a static readonly ReactiveCommand of type UiEventParam
    private static readonly ReactiveCommand<UiEventParam> _uiEventParam = new ReactiveCommand<UiEventParam>();
    
    // Create a method to raise an event with a generic type
    public static void Raise<T>(this UiEvent evnt, T data) 
        // Execute the ReactiveCommand with a new UiEventParam object containing the event and data
        => _uiEventParam.Execute(new UiEventParam<T>(evnt, data));
    
    // Create a method to subscribe to an event with a generic type
    public static IDisposable Subscribe<T>(this UiEvent evntType, Action<T> action)
    {
        // Return a subscription to the ReactiveCommand, filtering for the specified event type
        return _uiEventParam
            .Where(evnt => evnt.Type == evntType)
            .Subscribe(evnt =>
                // Execute the action with the data from the UiEventParam object
                action(evnt.Get<T>()));
    }

    public static IObservable<T> Where<T>(this UiEvent evntType, Func<T, bool> predicate)
    {
        // Create an observable sequence from the UiEventParam
        var observable = _uiEventParam.Where(evnt =>
            // Check if the event type matches the given event type 
            // and the predicate returns true
            evnt.Type == evntType && predicate(evnt.Get<T>()));
        
        return observable.Select(evnt => evnt.Get<T>());
    }
} In the example above, we created the class for generalized access to the field of the class, and we also added the method that allows filtering events based on the passed data. With these changes, we can further expand the possibilities of using the event bus: UiEventParam Data UiEventParam<T> Where void ExampleOfRaising()
{
    // Raise the SetSoundVolume event with a value
    **UiEvent.SetSoundVolume.Raise(0.5f);**
}

void SubscribeOnEvents()
{
    _disposable = new CompositeDisposable
    {
        // Subscribe to the SetSoundVolume event with any value
        **UiEvent.SetSoundVolume.Subscribe<float>(OnSetVolume),**
        
        // Subscribe to the SetSoundVolume event
        // and call the OnMute method when it is raised with a value of 0f
        **UiEvent.SetSoundVolume.Where<float>(x => x == 0f).Subscribe(OnMute),**
    };
} Encapsulating network events in an enum-based bus Similarly, we can wrap any network interactions in an enum-extension, whether that’s message exchange with the backend, or anything else. Let's consider the example of the network library . We'll write a C# extension that wraps the receiving and sending of events in an enum called : Photon Unity Networking 2 NetEvent public static class NetEventExtensions
{
    // Create a new ReactiveCommand of type NetEventParam
    private static readonly ReactiveCommand<NetEventParam> 
        _netEventParam = new ReactiveCommand<NetEventParam>();

    // Extension method to raise a NetEvent with data
    public static void Raise<T>(this NetEvent evnt, T data)
    {
        // Raise the event with the data, options, and reliable send
        PhotonNetwork.RaiseEvent((byte) evnt, data, GetOptions(evnt), SendOptions.SendReliable);
    }

    // Extension method to subscribe to a NetEvent
    public static IDisposable Subscribe<T>(this NetEvent evntType, Action<T> action)
    {
        // Return a subscription to the ReactiveCommand, 
        // filtered by the event type, 
        // and call the action with the data
        return _netEventParam.Where(evnt => evnt.Type == evntType)
                             .Subscribe(evnt => action(evnt.Get<T>()));
    }
    
    // Method to be called when a PhotonEvent is received
    public static void OnPhotonEventReceived(EventData data)
    {
        // Cast the data code to a NetEvent
        var evnt = (NetEvent) data.Code;
        // Execute the ReactiveCommand with a new NetEventParam containing the event and custom data
        _netEventParam.Execute(new NetEventParam<object>(evnt, data.CustomData));
    }
} The method should be called in your class implementing the . We can now work with network events, just like we did before, with UI events: OnPhotonEventReceived Photon interface IOnEventCallback.OnEvent // Enum for network events
public enum NetEvent
{
    // Event for player state
    PlayerReady,

    // Event for client ping
    ClientPing,

    // Event for battle finish
    BattleFinish,

    // ...
}

// Method to raise the PlayerReady event
public void OnGameLoaded()
{
    // Raise the PlayerReady event with the player's ID
    **NetEvent.PlayerReady.Raise(_playerId);**
}

// Method to subscribe to the PlayerReady event
public void SomeGameManagerOnAnotherDevice()
{
    _disposable = new CompositeDisposable
    {
        // Subscribe to the PlayerReady event
        **NetEvent.PlayerReady.Subscribe<int>(OnPlayerReady)**
    };
} Other types of buses A bus can be characterized not only by the method of delivery, but also by the environment for message propagation. The above examples show buses that deliver events at runtime, but we can also identify a separate bus for editor events (in Edit and Play-mode): [InitializeOnLoad]
public static class EditorBridge
{
    // Static constructor that is called when the class is loaded
    static EditorBridge()
    {
        var disposable = new CompositeDisposable
        {
            // Subscribe to the event and log a message when it is raised
            **EditorEvent.SomeEventName.Subscribe**(() => Debug.Log("Editor event"))
        };

        // Add a handler to the EditorApplication.quitting event
        // that disposes of the CompositeDisposable
        EditorApplication.quitting += () => disposable.Dispose();
    }

    // Create a menu item in the Tools menu
    [MenuItem("Tools/Raise Test Event")]
    public static void RaiseTestEvent()
    {
        **EditorEvent.SomeEventName.Raise();**
    }
} In this case, the implementation of the and methods will not differ from . In Edit-Mode, the event bus can be used to exchange messages between different custom editors, allowing for interface updates and synchronizing data between them. Subscribe Raise UiEventExtensions Another useful type of bus is a . In the previous examples, the sent event is executed synchronously in the same frame. However, there are tasks that require time for processing but do not demand immediate execution. For such events, a separate manager is required which will check whether there is enough time in the current frame to execute the handlers, or whether to wait for the next frame: deferred execution bus public class DelayedEventsProcessor
{
    // This method is called when the game starts
    [RuntimeInitializeOnLoadMethod]
    public static async void Init()
    {
        // Create a cancellation token source
        var source = new CancellationTokenSource();
        // Store the current delta time
        var time = Time.deltaTime;

        // While the cancellation is not requested,
        // the queue is not empty
        // and the execution limit is not exceeded
        while (!source.IsCancellationRequested 
               && !DelayedEventsQueue.IsEmpty()
               && (Time.deltaTime - time) > ExecutionLimit)
        {
            // Process the events in the queue
            DelayedEventsQueue.ProcessEvents();
            // Waiting for next frame
            await Task.Yield();
            // Update the delta time
            time = Time.deltaTime;
        }
        
        // When the application is quitting, cancel the token
        Application.quitting += () => source.Cancel();
    }
} One can separately highlight the bus, and its events will only be handled in development builds and will be turned off in release configurations. DebugEvent Pros and cons of event buses Using the event bus pattern improves Unity game architecture, simplifies development and maintenance, and enhances flexibility and performance. Let’s look in more detail: : The Event Bus pattern allows for the separation of game logic into components, which simplifies its understanding and maintenance. Each component can process only the events it needs, reducing coupling and increasing system flexibility. Separation of logic : Using an event bus makes it easy to add and remove components, simplifying game expansion and functionality changes. Flexibility : Events processed through the bus can be called asynchronously, improving game performance and reducing the likelihood of delays in operation. Asynchronicity : The event bus pattern can be used to create plugins and modules that can be easily integrated into the game. Extensibility However, it should be remembered that the Event Bus can also lead to some negative effects: : events that are processed through the bus can be triggered asynchronously, which makes it difficult to debug the application. Worsening of debugging : if event processing is not organized correctly, unpredictable interaction between components may occur, leading to errors and failures. Loss of flow control : code that uses the event bus may be harder to understand and maintain, as different components may be subscribed to the same event. Increased code complexity : transmitting messages through the bus can increase the delay in application operation, as events must be processed at the other end of the bus. Increased message transmission delay Conclusion We’ve learned how to use enums to mark data buses and message types, and have explored how to wrap event buses transmitted in different ways and in different environments with enums. Putting it all together, we can use this approach to uniformly handle any type of event, thereby improving code readability and comprehension. public void Initialize()
{
    _disposable = new CompositeDisposable
    {
        // Uniform subscription to events 
        // incoming from different buses

        **UiEvent.ExitBattleClick**.Subscribe(OnExitBattleClick),   

        **BackendEvent.BattleReset**.Subscribe(OnBattleReset),

        **DelayedEvent.ChangeWindDirection**.Subscribe<Direction>(OnChangeWindDirection),

        **NetEvent.PlayerReady**.Subscribe<PlayerReadyData>(OnPlayerReady),

        **DebugEvent.KillOpponentUnits**.Subscribe(OnKillOpponentUnits),

        **EditorEvent.SelectScene**.Subscribe<string>(OnEditorSelectScene),
    };
} To recap once more: the event bus pattern has several advantages, such as reducing the coupling between components, more flexible and extensible code, and the ability to handle messages asynchronously. However, its use can lead to code complexity and increase the difficulty of debugging the application. Therefore, before using the pattern, it is necessary to carefully evaluate its necessity and advantages in a specific project. . Source code is available on GitHub

Using an Enum-Based Event Bus Pattern In Unity

How to Use React Native to Build a Private Messaging App

How To Connect AWS Amplify with React Native Application

The Complete Guide for using Redux in React Native

Remote working has gained so much popularity over the years in almost every career field. Even in professions where remote working wasn’t allowed, it has now become the only option due to the Covid-19 pandemic. Working online isn’t difficult, but it’s not so straightforward, either. Here is a detailed guide about everything you need to know about working online. Skills and Roles There is so much work that you can do online. However, it all depends on the work’s nature and the company’s preferences. Generally, if you want to start working online, you should focus on roles like programming, writing, or anything revolving around design. However, you can also work remotely if you are a: UX designer Virtual assistant Online tutor App developer Translator Customer advocate Transcriber Above are just the most popular roles done online today, but there is still much more that you can do. Experience Online work is all about showing what you can do. Therefore, you have to prove you are the best. Luckily, there are many online courses nowadays that can help you gain some vital skills. That way, you’ll have a remarkable portfolio and results-driven work helping you stand out. Below, are excellent soft skills that every professional remote worker should acquire: Self-discipline Communication Adaptability Initiative Responsibility Problem-solving Accountability Time management You now know the skills you need and the roles that you can perform online. So, let’s look at vital tools that you must have to ensure excellent results. They include: 1. Remote Desktop Software Did you know that you can use a computer that’s miles away like you’re in front of it? That’s the primary purpose of remote desktop software. With such software, employees can easily access computers in their company’s headquarters without even going there. This software also makes it easier for the IT department to troubleshoot technical issues for colleagues at home. If you want to use remote desktop software, all you have to do is set up remote access on your PC. A good example is the Windows’ Remote Desktop Client that is very easy to use. You can also go for the Apple version (Apple Remote Desktop), which might cost you around $80. Other great options that you can try are Chrome Remote Desktop and TeamViewer. 2. Mobile Hotspots Having a strong internet connection is one primary necessity when working remotely. Therefore, it is vital that you install reliable WIFI in your home but still ensure that every person on your team has a mobile hotspot. With a mobile hotspot, you can’t experience any inconveniences if the power or your internet runs out since you have back up. There are different pocket-sized WIFI devices that you can buy nowadays. A high-quality WIFI hotspot device should cost around $100 or less. If you don’t have any hotspot device, then you can also use your phone. Turning on the hotspot feature on your smartphone will allow you to use it as a WIFI device hence enabling you to continue working on your projects. 3. Time Management Software Excellent time management is crucial in online work since you have to meet all the set deadlines. is among the best time management software out there. This app helps you organize your assignments professionally and allocate enough time for everything. That way, it’s easier to hit targets since you’re more focused, and you also can’t forget to perform any crucial task. Traqq 4. Team Chat Apps When working remotely, you need to effectively communicate with your boss, colleagues, or employees to ensure excellent work. Most companies today use emails, but it’s not the only way to communicate, and it might not be the best fit for your organization. Other team chat applications that you can try today include: Slack Microsoft teams Google hangouts Twist ChatWork Mattermost 5. Video Conferencing Tools Sometimes, sending emails and messages might not be enough, especially when it comes to illustrating a technical project. With an excellent video conferencing app like Face time and Zoom, you can arrange a virtual meeting with your boss and colleagues and address any issues fast. That way, you get comprehensive answers, thus allowing you to complete projects more accurately. 6. Screen Sharing Software Explaining technical issues on a video call might not always be helpful because some people won’t understand the crucial concepts clearly. Screen sharing is an excellent option as it allows you to share your PC screen with employees. That way, they can see everything you’re doing on your computer, hence making it easy to explain how to complete critical tasks accurately. Slack is one popular screen sharing software that most professionals love. However, you can also use other excellent alternatives such as GoToMeeting, Surfly, Upscope, Use Together, and Screenleap. 7. Online Office Suites Nowadays, you don’t have to install Office software packages on your PC as you can just use them online. So, you can now share Word, PowerPoint, Excel, Slides, Sheets, and more with colleagues and see any comments or changes made in real-time. That way, you can quickly get advice on anything you might have done wrong hence allowing you to correct it immediately. 8. Cloud Storage Having a cloud storage app is also vital as it allows you to share critical files with other employees easily. That way, it’s easier to access any data you need to complete your work from the app. A cloud storage app also helps a lot when you’ve lost a particular document since you know where to find its back up anytime. You can try cloud storage apps like Google Drive, Dropbox, OneDrive, and Sync. As you can see from this article, there is so much to learn about remote working. Therefore, make sure you acquire the vital skills and tools that you need before you start working online. Doing that will help you to be more productive hence ensuring better results. Also, being well prepared will enable you to be a better professional in the career path you choose to follow in online work. References https://traqq.com/blog/7-disadvantages-of-working-from-home-and-what-to-do-about-it/

Employee Cheat Sheet: Mastering Remote Working

The demand for software developers is ever-increasing, with many industries turning to IT for help concerning marketing, automation processes, etc. It's estimated that by the end of 2019, the total number of software developers will count over 26 million. Scattered around the globe, could prove to be a difficult job for managers. managing them online Some of the obstacles include: Scheduling Largely connected to different time zones, scheduling tasks and deadlines is a very important matter in project management. This is why it’s important to use the right project management tools when managing a remote team. Language & cultural differences As mentioned above, over 26 million programmers will be available for work by the end of the year, meaning workers coming from different cultures and practicing various religions will join your company. Tracking performance Remote workers are paid by the hour. Thus, it's required of them to fully focus on the tasks at hand and minimize slacking. However, you can't really tell what your worker is doing in front of the computer. Lack of trust and team cohesion Although remote software engineers can remain loyal to a single company for years, there's often a lack of trust between them and managers. Sometimes, it's favoring one person over another and other times, it's simply a difference in characters. Communication Conducting head-to-head conversations is still a major issue when managing remote teams. Apart from talking things over during company retreats and team-building events, you don't get to see your employees for the rest of the year. Let’s dive into specific categories of tools. Project management Finding the perfect app to manage both remote workers and essential projects isn't as easy as many would imagine. Luckily, there are plenty of online project management solutions based on various methods. These are the best of the best. GanttPRO : $15 for personal needs, $5.90-$7.90 for teams based on the number of users. Trial version available for 14 days. Price : average of 4.6/5 at G2Crowd and 4.5/5 at Capterra. Rating Used by over 350.000 project managers and by companies from every industry, GanttPRO app makes life easier for every remote team. Some of its best features include: Famous Gantt chart. It truly assists in every aspect of managing. Prioritization. Time & expense trackers. Resource management. Export and sharing. Team collaboration. JIRA and Google Drive integrations. Due to the multiple tracking and management features, as well as acceptable prices, GanttPRO is the ideal tool for any company, small or large. Jira : starting at $10. Trial version available for 7 days. Price : average of 4.1/5 at G2Crowd. Rating With a dashboard design similar to Trello, Jira is easy to plan and track all tasks. Users can add many apps via Atlassian Marketplace to upgrade the existing software. Some of its best features include: Measuring the amount of work employees can do during working hours. Product release forecast. Budgeting. Time tracking. Overall, Jira is a great tool to have that is easily upgradeable. For managers offering more in-app options for the staff, it's a good addition. Trello : free forever. Paid plans are available at $9.99 and $20.83. Price : average of 4.4 out of 5 stars at G2Crowd. Rating Trello is a well-known management app, incredibly easy to use and with flexible plans, including a free one. Some of its best features include: Setting deadlines. To-do lists. Different dashboard views. The ability to upload various media. For those who want to keep it simple, Trello is the right choice. Beginners can easily join conversations and contribute to all boards, without wasting any time on functionality. Why is Trello good for project management? Due to its simplicity, thousands of companies use it to create boards and delegate daily tasks to the staff. File Management Every company needs a stable file management service to store all projects and media files. Every user is allowed to test out the following apps and choose whichever suits them the most. Google Drive : free up to 15 GB per user. Paid plan starts at $8/month. Price : average of 5/5 at both Capterra and G2. Rating Everything Google does is of the highest quality, and so is their storage management software. It has already crossed the '1 billion users' mark and is way ahead of its competitors. Why do millions of users have it bookmarked? Easy usage, the free version features, and its 'drag & drop files' option are perfect for any programmer and designer in need of safe file storage. Box : starts at $5/month. Four plans available for small and large companies. Price : average of 4.5/5 stars, Box has received generally positive reviews. Rating Box may not be as popular as Google Drive, but it still lets you organize files efficiently and share folders with the rest of the staff. Perfectly adjusted for mobile functionality, Box supports a wide range of file types and supports device syncing, especially between PC and smartphones. Dropbox : offering both free and paid plans for individuals and businesses, it starts at $9.99 per month. Price : average of 4.5/5, making it a great alternative to Google Drive. Rating Dropbox has been around for a decade and is still one of the best file hosting services around. Supporting multiple OS, it's ideal for remote teams. Users can set storage limits, change between multiple languages for better navigation, while managers can report user activity between folders. Communication Lack of communication leads to distrust and it's essential that you keep everyone in the loop, at all times. We're giving you the few options used by millions of companies and individuals so that every member of the staff is engaged in brainstorming, screen sharing assistance, and task performance. Join.me : this famous meeting app starts at $10 for individuals, depending on the number of allowed features per plan. Price : average of 4.5 stars at Capterra, based on the opinion of over 800 users and 4.2 stars at G2Crowd. Rating Users praise join.me for its simplicity and video quality, giving it an excellent rating. You can schedule and attend internal meetings, as well as manage attendees remotely. Screenleap : for small companies, there's a free plan giving up to 40 free minutes a day. Paid plans begin at $15/month. Price : average of 4.1/5. Rating Users love its user-friendly interface, multi-platform usage, and for not having to install it on their laptops. Screenleap is used by companies such as Home Depot and Whole Foods Market. Zoom : similar to Screenleap, the free version offers limited options, while 'Pro' plans begin at $14.99 per month. Price : average of 4.5/5 stars. Rating Zoom is a pioneer in video conferencing, known for taking care of its employees and customers. The only piece of the puzzle missing are more features in the free version. Still, it's ranked number one on multiple app review sites. Some of the Internet's most famous companies use Zoom for video conferencing, including Dropbox, GoDaddy, UBER, and the board of directors at Atlassian. Why Zoom? It's designed to work flawlessly, it's easy to use and adapted for senior managers, and helps develop discussions with its comment, voting, and instant messaging features. Slack : while there is no free version, the 'Standard' plan begins at $7/month per individual. Price : based on the opinions of over 30.000 reviewers, it has an average rating of 4.5 out of 5 stars. Rating Slack has officially passed the '10 million users' mark at the beginning of 2019, making it the most used remote communication software ever. By winning several awards for its ease of use, Slack proves to be a great app for tasking, brainstorming, and instant messaging. Pukkateam : all plans are free for the first two weeks, then you get charged for as little as $7 per month. Price : the relatively new remote communication app is quickly gaining on its competitors. Rating Pukkateam may not be as famous as the other apps on the list, but it's still used by remote teams around the globe, including companies like Tesco, Shopify, RyanAir, and Cisco. Some companies love short , such as showing who has the neatest office desk, etc. team building games Security With so many hackers trying to break into the servers of famous corporations, startups are easy targets. Security is an important step to make before any sensitive information is stored in the servers. 1Password : it costs as little as $3.99/month per user, for businesses and remote teams. A free trial is included. Price : average of 5/5 for its efficiency and enhanced security measures. Rating 1Password is one of the best password management apps ever built, offering to store and create all your passwords, making it impossible for hackers to break in your private emails and credit card information. To make our lives easier, 1Password does not only create and store passwords, but there are several folders you can create, containing passport information, bank accounts, and credit cards, IDs, and even driver licenses. Spinbackup : for just $5 flat ratep er month, you'll get complete security and backup for your teams. Free trial and demos are included. Price : it's another full-star app. Rating Spinbackup is used by thousands of companies, mainly to assist with G-Suite and Office 365, safeguarding all business data in the process. Companies love the encryption feature, cloud backup scheduling, and allowing local and remote servers to get connected. Time Tracking Time is money, and money can't be made if remote workers aren't focused on the tasks at hand. Tracking the working hours and completed work will get you the finest employees - the most productive ones, at least. Toggl : the basic plan is always free, while users get a 30-day trial period to explore all options. Price : 4.5 out of 5 stars for its simple design and value for money. Rating CEOs and project managers love this effective time-tracking app for multiple reasons, including the ability to track multiple activities. Besides the usual features, you can see how much a programmer has spent on research, learning, and project tasks. Teamwork Timer : for small teams, there is the 'free forever' plan. Otherwise, paid plans begin at $9 per month. Price : With an average of 4.3/5 at G2Crowd, Teamwork is among the top 5 time tracking apps available. Rating Users praise Teamwork for increasing their work productivity and helping them manage time better. Features include a panoramic view of all projects, messaging, and a general board view. Overall, a great time tracker. Harvest : this time tracking software is relatively cheap, with prices for both individuals and teams beginning at $12 per month, although a single user can activate the 'forever free' plan, working on two separate projects. Price : excellent reviews of 4.5/5 stars make it ideal for companies in the IT sector. Rating Project managers can create visual reports from all data collected, and then check expenditure per hour and project completion. Additional features include project budget alerts, apps integration, multi device availability, and price discounts. Invoicing & Documents Managing remote teams' finances and getting documents in order is often stressful. There are ways to improve and save time on printing invoices with the following apps. Freshbooks : starts at $15, while small businesses can get the 'Plus' plan for just $25 per month. Price : average of 4.5/5 stars on several relevant app reviewing sites. Rating One of the good things about this app is the custom functionality and various workflows. Credit card integration, automated bank importing, and time tracking with estimates are some of the coolest features. TransferWise : it's free to order a TransferWise debit card, and they only charge small fees for transfer and converting between currencies. Price : TrustPilot reviews show a high rating of 9.2/10 stars, making it a highly reliable app to transfer payments and save money for both companies and remote staff. Rating With Virgin's owner as a key investor and over 4 million users worldwide, this money transfer service is relatively cheaper than PayPal. Some of its best features include sending money to over 70 countries worldwide, converting to over 40 currencies, and get paid like a local in some countries. Hellosign : starts at $299, while you can use it for free if you make less than 100 transactions per month. Price : based on over 100 reviews, the digital signature app has an excellent 4.5-star rating. Rating Hellosign is a digital signatures app, letting managers sign invoices and other important documents online, for which they are legally obliged to fulfill. As a bonus, you can authorize other members to sign documents, or simply sign via mobile. In case you forget, there are auto-reminders to keep you updated. Lawgood : they charge $95 per contract review, for 10 pages or less. Other plans exist, depending on the company's needs. Price : unfortunately, you can't find many reviews for this app, being only a couple of years old. However, the ones to be found show a 5/5 rating, since not many people have thought of this idea before. Rating Lawgood is an innovative app in the IT industry, allowing managers to write agreements and contracts without having to consult a lawyer. Experienced attorneys do it for them, reviewing every single page and editing it to perfection. Other options include faster turnaround time, and tips on how to improve contracts, followed by direct calling. Code Management Remote programmers, no matter how experienced they may be, still need assistance on projects. Sometimes, even communication and problem solving sessions with fellow colleagues will result in the status quo. However, these tools help fill in the gaps and solve almost any coding stump. Screenhero : being bought and integrated into Slack's app database, it's included in the latter app's pricing plans. Price : reviews on Trustradius show a high 9.2/10 score, meaning this screen sharing software is highly recommended for any remote coding team to solve problems. Rating Screenhero allows users to share multiple screens and conduct brainstorming sessions without interruptions. As part of Slack, you get this app along with hundreds of other features and apps, as per request. GitHub Wiki : there's a free version, as well as plans beginning at $7/month, for both small companies and major corporations. Price : based on almost 2000 reviews at Capterra, its rating is straight 5/5 stars, given by coders from all around the globe. Rating GitHub is simply a distributed source code management tool that serves as a hosting service for repositories. With its great graphic interface, it offers hosting for project versions used by developers and helps fix many errors in the process. Pros include visualized changes, easily deployable code, and centralized repositories. zipBoard : there is a free/limited plan. Paid plans start at $39 for individuals and $79/month for teams. Price : rated as 4/5, zipBoard is among the few apps focused solely on bug tracking. Rating The app helps developers get rid of those pesky bugs in the code more easily and efficiently. It's a 'must' for every remote team and saves a lot of time on fixing errors. Filtering and issue tracking are some of its pros, with task management added as an extra feature, to make it whole as a bug-tracking software. Conclusion Using any of these tools is the right decision for project managers to really get things going. Teams working remotely are hard to manage, so you'll need all the help you can get. For every process, there are multiple apps to choose from (or combine) and get the best of it. Without using at least a few of these apps, losing both time and money is inevitable. Intelligent leaders know the importance of it and invest in automating tasks, allowing them to focus on everything that needs attention. Which ones would you use? Have you used any of these so far? What are your impressions? Share your opinion with your fellow programmers!

23 Time-Tested Apps to Manage Your Remote Software Development Team

Android Unidirectional Data Flow with LiveData Improving Coinverse’s Performance and Structure (UDF) pattern has improved the usability and performance of since the first beta launched in February. Coinverse is the first app creating audiocasts covering technology and news in cryptocurrency. Upgrades using UDF include more efficient newsfeed creation, removal of adjacent native ads, and faster audiocast loading. The Unidirectional Data Flow Coinverse The UDF pattern organizes the app into three main areas, view , and ensuring the app is modularized and reliable. I learned of the UDF pattern from episode 148 of the , with at and . On first listen it was interesting, but a large overhaul. UDF became compelling as I worked on fixing bugs and realized how complex various flows had become. state, events effects Fragmented podcast Evolving Android architectures (Part 1) Kaushik Gopal Instacart Donn Felker The examples of UDF I’ve seen thus far have been with . Rx a powerful and customizable tool for creating streams of data that can be observed in real-time. However, provides the same benefit of observing state changes and on top of that is simple, directly integrates with Android’s , and handles Android’s lifecycle events by default. If unfamiliar, check out Google’s ’s . To try out UDF I refactored the newsfeed flows in Coinverse as we’ll walkthrough below. Rx LiveData architecture components Jose Alcérreca talk on LiveData <a href="https://medium.com/media/8b9dd6f492bd3f25f79f7bf5cbe0388e/href">https://medium.com/media/8b9dd6f492bd3f25f79f7bf5cbe0388e/href</a> UDF Background UDF pattern, a.k.a. or was originally popularized in web development with Facebook’s and state management, and UI libraries. Early Android can be found from and at in 2015. ’s talks on Rx educated developers on which are fundamental to UDF. Unidirectional Data State Flow React Readux Flux experimentation Brian Egan Guillaume Lung SoundCloud Jake Wharton reactive programming Growing Number of Android Apps Adopting To name a few… and @ Kaushik Gopal Laimonas Turauskas Instacart @ Robinhood Dan Hill @ / Lyft Donald Chen Instagram Engineering @ Microsoft Cesar Valiente App companies adopting UDF Model View View Model — MVVM Gem Lake, Yosemite Emigrant Wilderness Trail For the first iteration of Coinverse I used the (MVVM) approach. MVVM separates the UI from the business logic, improving readability and organization. However, as an app grows with MVVM it becomes a lake of data. Information flows in, out, and around at many points via and with , and . This adds complexity for keeping track of logic, debugging, and testing, which requires mocking many components. Model View View Model Activities Fragments Data Binding, ViewModels Repositories UDF Advantages pc — , Waterfall at Yosemite National Park Ned Scher UDF is a waterfall, information flows in one direction through a single source providing many benefits. One point of entry for streams — The UI and business logic interact through single points of entry. Control UI involving async events — Know exactly when and where things begin and finish Debug issues — Easy to follow sequence of events and identify errors Streamlined tests — The majority of logic is contained in the ViewModel requiring less mocking. LiveData LiveData provides a straightforward approach to implementing UDF. Lifecycle aware Can emit multiple or single events Concise code Quick to implement <a href="https://medium.com/media/aece5d95a459fab51fe4afcff559f91b/href">https://medium.com/media/aece5d95a459fab51fe4afcff559f91b/href</a> View State, Events, and Effects ViewState Coinverse’s main newsfeed View is responsible for holding the final view’s persisted data. This entails all of the content shown to a user on a screen, including information about the content such as enabled statuses. state Looking at Coinverse’s main newsfeed above, examples of view include the contents of the toolbar, what timeframe and the feedtype of feed to display, as well as the contentList to populate the feed with. state Events ContentSelected(…) View consist of both user interface and system initiated actions. UI actions include button presses and text input, whereas system actions might be Android lifecycle events and screen rotation. events In the case of content selected above a view is created, ContentSelected. The will share information with the business layer to initiate the retrieval of the audiocast selected. The Coinbase Blog’s event event Effects ContentSwiped(…) View are one time UI occurrences that don’t persist. include navigation, dialogs, and toasts. are created by the business layer to initiate changes in the UI. effects Effects Effects When the item above is swiped right, the business layer adds a label to the content. The business layer sends an , ContentSwiped**,** informing the UI of the change in the content’s label. The UI can then remove the content from the main newsfeed. CCN saved effect App Structure Let’s understand how the one-way flow of data is structured. The handles all UI and system level actions stored in a single stream. The stream is sent to the that receives the actions and handles them accordingly in the business logic. View ViewModel The is the source of truth for the view and creates any necessary . The also handles requests to the data layer, managing the results , success ( ), and states returned from the with an Lce object (more on Lce's below). ViewModel state effects ViewModel Repository loading content error Repository Both the and are observed by the updating any changes from the in real-time. state effects View, ViewModel Implementation mainfeed loading We’ll use Coinverse’s main newsfeed loading as our example for how to implement UDF. Step 1 of 6 — Define Models <a href="https://medium.com/media/e3e457ec723be5f770f4c050214571d0/href">https://medium.com/media/e3e457ec723be5f770f4c050214571d0/href</a> View Stored as a LiveData object in the storing the contentList of LiveData type state — ViewModel, View and — Use Kotlin’s to pass one time events event effect Sealed class The view uses LiveData because it’s important the data is immutable vs. MutableLiveData. Otherwise, the flow of data would not be unidirectional, and the state could be changed in many places. state View and are not persisted in the . A Sealed class, like an Enum, but on a class level, is used to pass information. Sealed classes define a parent and child class with or without data. TheScreenLoad is a data class with data about what the should load. Whereas the UpdateAds is a class without data telling the view to update the ads in the newsfeed. events effects ViewModel event ViewModel effect Step 2 of 6 — Pass events to ViewModel <a href="https://medium.com/media/21b7345af796983c640793c3fbfdf7ee/href">https://medium.com/media/21b7345af796983c640793c3fbfdf7ee/href</a> In this example, when the system action of onCreate occurs, a ScreenLoad event is added to the stream of view events and sent from the to the to start creating the main feed. Fragment ViewModel All of the events created in the / are added to a object _viewEvent, a MutableLiveData object which updates the immutable LiveData object. I’m using the pattern of passing all of the events in onResume based on ’s . View Fragment LiveData Kaushik sample The LiveData stores data wrapped in an Event. As explained by in his , events ensure a single unique object is added to a stream. This avoids the accidental creation of multiple objects for a single action. Jose LiveData post about events Step 3 of 6 — Process events mainfeed loaded <a href="https://medium.com/media/1e82719128462cbbc400fb2ceab73db4/href">https://medium.com/media/1e82719128462cbbc400fb2ceab73db4/href</a> The receives incoming events, handling each event in a when statement based on the type of ViewEvent class. For ScreenLoad, the entireViewState is updated with the required data. To populate the newsfeed a request to the with getMainFeed is made. ViewModel Sealed Repository Update State Value In cases where an attribute of the ViewState needs to be updated rather than the entire ViewState, Kotlin’s shallow function is useful. copy <a href="https://medium.com/media/ce1bf00297c228e57a7216047f915529/href">https://medium.com/media/ce1bf00297c228e57a7216047f915529/href</a> Step 4 of 6 — Manage Network Requests with LCE Pattern <a href="https://medium.com/media/abb3971ab92689aa13784def4501b3e3/href">https://medium.com/media/abb3971ab92689aa13784def4501b3e3/href</a> To manage network requests, introduces the Lce class object with three states, , , and . The state represents a successful request. Kaushik Sealed loading content error content <a href="https://medium.com/media/115cf44f615dca588145ff82c08df8f1/href">https://medium.com/media/115cf44f615dca588145ff82c08df8f1/href</a> A class is also useful for returning different types of results. Sealed <a href="https://medium.com/media/0282a893889f04b825cc9f73d6a231fb/href">https://medium.com/media/0282a893889f04b825cc9f73d6a231fb/href</a> getMainFeed’s network request shares send the Lce states to the via the LiveData stream. The PagedListResult class can be passed into the Lce for both the and states. The will then manage each state appropriately. ViewModel content error ViewModel Step 5 of 6 — Handle LCE States mainfeed error The gif shows something has gone awry. We’ll see how the error is handled in the . ViewModel <a href="https://medium.com/media/2e31d1bd3a6304c6a19b4728f9102597/href">https://medium.com/media/2e31d1bd3a6304c6a19b4728f9102597/href</a> UDF has streamlined both methods of requesting new content from the network and retrieving the updated content from the database. Prior to using UDF, Coinverse called two repository methods separately to populate the main newsfeed. Room When the feed is loading the existing Room database content is returned so that the user is not staring at an empty screen. For the successful Content case, the updated content from Room is returned. For errors requesting new content, the existing Room content is also displayed similar to theLoading case. In the error above, a SnackBar view is passed to the to display the error message. effect Fragment The observes each Lce state with a LiveData SwitchMap. The SwitchMap passes in one LiveData object and returns a new and different LiveData object that is saved to the view . ViewModel state Like all LiveData, a SwitchMap must be observed in the view in order for the value to be emitted within the map inside the . ViewModel Step 6 of 6 — Observe State Change! <a href="https://medium.com/media/503f19392a8e77dba776d7ab367549a1/href">https://medium.com/media/503f19392a8e77dba776d7ab367549a1/href</a> Now the view may be observed when an update occurs. The view are observed in the same way. state effects Bonus — Removing Adjacent Ads auto adjacent ads detection In addition to a streamlined newsfeed above, UDF has improved how Twitter’s native ads are shown in the newsfeed. MoPub’s MoPubRecyclerAdapter does not have a built-in approach to avoid adjacent ads from showing. Content can be swiped to be saved or dismissed, eventually causing two ads to appear next to each other. Prior to UDF, this was handled with a manual swipe-to-refresh by the user. MoPub With UDF there is a contentLabeled view . When the status of the view changes, meaning an item is labeled to be removed from the main feed, a check for adjacent ads is made. If removing the content creates adjacent ads, the ads are automatically refreshed. state state Trade-Offs Using LiveData for the Unidirectional Data Flow has been great, but it’s not perfect. LiveData is only applicable for logic impacting the UI. For non-UI logic LiveData will not be observed since it requires lifecycle to be passed in. For these instances, or Rx may be used. If no UI is involved then an even better solution might be to offload the logic completely to the backend with . Kotlin coroutines Firebase Cloud Functions There’s not as much customization with LiveData for things like threading. With this year’s latest Google I/O updates coroutines appear to easily integrate with LiveData offering more customization. Coinverse Next Steps Expanding to the rest of Coinverse’s app Unidirectional Data Flow — — Now that the majority of the newsfeed logic is modularized in the , JUnit testing will be easier with less mocking of components. JUnit testing ViewModel Exploring integration with LiveData Kotlin coroutines — Resources Slides — @ Unidirectional Data Flow por Adam Hurwitz Medellín Android MeetUp Notes — Unidirectional Data Flow guide I’d love your feedback on the beta! Coinverse to be updated on a Unidirectional Data Flow sample app and more. Follow me A to and of the for organizing the talk! If you are in Medellín I recommend stopping by their MeetUp. big thanks Cristián Gomez Carlos Daniel Medellín Android MeetUp Medellín Android talk — Unidirectional Data Flow por Adam Hurwitz

Stories, News & Mentions about SCREENLOOP

Categories

Trending Topics

Stories, News & Mentions about SCREENLOOP

Screenloop’s Stories on HackerNoon

Categories

Trending Topics