Did you know that there are over 135,600 actors in the US alone? According to one estimate, only 0.04% of all applicants get an official acting role. This means that about 339 million people have applied for acting jobs. Not only do these people need to attend multiple interviews but they also have to regularly check dozens of Facebook groups for actors, spending hours scrolling through posts in search of a casting or shooting session.
This is why our client, Edward Holt, decided to create Proreel, a platform to bring actors and shoot managers together and streamline their collaboration. We built a mobile platform for web, iOS, and Android that includes multiple user roles, various input forms, sophisticated tools to find candidates and schedule appointments, and an impressive list of other features. Keep reading this post and you’ll discover what Proreel can offer users, how we developed the platform, and the main challenges we overcame.
Key features of Proreel
As we were developing the platform from square one, we had to build a whole set of features to bring the actors and managers together:
- Filmmakers, casting managers, and photographers need to schedule shoots, manage and communicate with their teams, and exchange documents.
- Actors and models need to track shoots, manage their work schedules, and communicate with other actors, models, casting and shooting team members, makeup artists, and managers.
All users of the Proreel platform needed to:
- Create profiles
- Connect with other users
- Create events
- Schedule and plan shoots
- Get notifications of new team members, new events, and event changes
In implementing all of these features, we encountered a number of challenges in design and in iOS, Android, and backend development. Let’s look at them in detail.
General UX approach
At the discovery stage, we mainly focused on сompetitive analysis and identifying user roles. We built user roles to understand how users would interact with the app and with each other. The idea was to know which activities users would perform and what content they would expect to see in the app.
We also wanted to create a community on the platform, so we needed to inform users about events so they could connect with each other. We built the Proreel app around the need to create and schedule events.
Identifying UX features
Dashboard. Inspired by the Airbnb dashboard, we created a dashboard that focuses on the most important part of the app: user profiles. The profile is where users can find all relevant information they need to be invited to events, as details about an actor or model are used to find the proper match for a shoot.
Events. Creating events and inviting other users is the top feature of Proreel. When creating an event, a user adds a title, description, location, and date. Once an event has been scheduled, a user can invite people to it. Invited users can accept or decline the invitation.
[Accepting or declining an invitation in the Proreel app]
Calendar. In the calendar, users see their past and upcoming events. This helps actors and models manage their schedules and plan their time.
[Calendar in the Proreel app]
Read also: How to Create a Calendar or Implement One in Your App
iOS development challenges
The project’s key functionality was implemented as various input forms built from repeating elements. Onboarding, user details, event creation — all of these screens have common elements that are widely reused in a variety of situations. The form contents vary depending on the user role. Static table views, which are often used to construct input forms, were not suitable for our case, so we looked for a more flexible solution.
After a bit of research, we decided to use the ReactiveCocoa framework for the iOS app. ReactiveCocoa helped us to detach the construction logic from the View layer, making the code well organized and easy to test.
Input elements are described as independent objects of various types: strings, numeric ranges, dates, and so on. Each input element has adjustable validation rules, a title, a value range, and other required options.
These input elements become contents of an InputForm object that generalizes the overall state, such as validity and changes made.
The form as a list of elements is displayed in a table view, where the cell UI is bound to corresponding input elements using reactive bindings.
Android development challenges
We first built the iOS app. Then the Android team had to create an Android app with the same feature set. But we had some technical challenges with the Android version.
Finding a solution to show the onboarding video on all devices. We had an onboarding video in .mov format. This works well for iOS, but .mov isn’t supported by VideoView in Android. After some discussion and research, we decided to use the ExoMedia library, which allowed us to play the .mov video on a cycle and crop it depending on the device viewport.
Updating locally stored data. One of the main requirements of the Proreel app was to download all data from a remote data source (the backend) to local storage and work with locally stored data. So our challenge was to keep data such as lists of events and user profiles in sync. To implement this functionality, we used the Repository pattern in conjunction with a Realm database and the Retrofit REST API client.
The Repository Design Pattern automatically chooses where to collect data — from the local source or from the server — and decides when the data should be updated. To elaborate the boilerplate code, we created a BaseDataSource interface and abstract realizations of this interface: BaseLocalDataSource and BaseRemoteDataSource.
Then we implemented a repository class for each entity type. The DataRepository class decides whether the View shows data to the user from the LocalDataSource, which manipulates local data, or the RemoteDataSource, which reads and writes data from the server. To deal with multiple repositories, we used RxKotlin.
For screens, we used the Model–View–Presenter architecture. Our Presenter requests information from the repository class but doesn’t know the source of the information.
Unifying work with lists in the application. The main function of lists is to show items, open item details, and support pull-to-refresh and pagination. That’s why we had to standardize work with lists in the Proreel app. To implement all the lists, we decided to create an AbstractListFragment class where we set up RecyclerView to display a scrolling list of elements based on large data sets. Moreover, we added a Paginate library with callbacks to create list pagination and a SwipeRefreshLayout class to realize the pull-to-refresh functionality.
Additionally, we created an AbstractListPresenter class where we allocated all pagination, pull-to-refresh, and load list data logic. This helped us use abstract classes for all lists, saving time on creating new lists and implementing basic functionality.
Implementing push notifications. As Proreel is a professional social network, we had in mind that users would get lots of notifications. We had challenging requirements for implementing notifications:
- Push notifications should be grouped.
- Invitations and notifications should have different designs but be shown on the same screen.
- All push notifications (except notifications about comments) attached to an event should be closed after the user opens that event.
- All notifications should be closed when the user logs out.
- Push notifications should disappear if the event has expired or the user has been removed from the event or the event has been deleted.
To implement notifications, we used FirebaseMessagingService and BroadcastReceiver. We customized Proreel notifications with the CustomContentView method.
According to the backend, we had two notification requests: an invitation list and a notification list. To encapsulate the base logic and use one list for two kinds of notifications, we created a BaseViewHolder extended from RecyclerView.ViewHolder and its siblings InvitationsViewHolder and NotificationsViewHolder. The proper view holder was selected based on viewType according to an overridden getItemViewType class.
To close specific push notifications after a user has seen them, we generated unique IDs on the backend for each push notification. This allowed us to close notifications by ID. The most interesting case was closing notifications about comments. After the user checked an event, we needed to close all notifications related to that event at once. That meant we had to receive a list of IDs for these notifications. We decided to get this list from the persistent storage with the specific event, filter this list by notification type, and then close all comments by notification ID.
Backend development challenges
Building the database architecture. The Proreel app has six user roles with different characteristics: actor/actress, film crew, model, photographer, hair and makeup, and casting director. We had the challenge of building a database architecture that would store attributes for all of these user roles.
It wasn’t rational to use gems like Rolify. Even though we had different user roles, the user flows were pretty similar. So we came up with our own solution that let us change the list of characteristics for each user role dynamically.
Searching for candidates for events. We had to implement functionality to search for appropriate candidates for different events. We built a search service that creates a list of candidates based on criteria.
If a casting director, for example, creates an event and adds characteristics and skills of the model they want to find, Proreel’s algorithm will use a filter search. The algorithm will find appropriate candidates and send them invitations to the event. Proreel’s filter search is based on users’ skills, gender, age, and location. To test this method’s performance, we used Apache JMeter.
Our team managed to build a platform for employees of the ﬁlm and photo industry with its own custom architecture:
[Custom architecture of the Proreel platform]
Thanks to this architecture and the set of features that the platform provides, filmmakers, photographers, and casting managers can easily find people for their teams and create and schedule new shoots and other events. Moreover, Proreel makes it easy for actors and models to learn about castings and shoots along with requirements.
Both we and our client were truly satisfied with the results of our cooperation:
Yalantis has proven to be a great option to get our startup from idea to completed project. Our company, Proreel, is a part-time endeavor, and having Yalantis as a partner has helped it move faster than we anticipated. I would recommend Yalantis to any startup looking for a development team.
Edward Holt, Proreel CEO
We also enjoyed working with Edward, as we got to help him make people’s lives easier. Don’t hesitate to contact us if you need any assistance with your app or platform!