The document describes a mobile app that allows anonymous chatting and partner finding. It includes implementations of chat/voting and partner finding features that store and sync event data in the cloud. The app aims to let users communicate and find partners anonymously without exposing their identities. It was developed using Google Mobile Backend Starter for the backend and includes features like anonymous group chats, event creation and browsing, and voting functionality. Future work includes adding further functionality to partner finding and improving security.

1. Cellular Mobile Network Final Report
Stay Anonymous
“TURN OFF THE LIGHTS”
Siyang Wu, sw2848
Farzaneh Motahari, fm2475
Marcus Hsu, mh3346
Li Yang Lu, ll2887
1.Introduction
As soon as the Internet developed, the means of communication over the Internet
developed, too. We’re in a world where most everything we do is public. You can be more
of yourself where you aren’t as concerned about crafting the right message. And there are
many ephemeral / anonymous app company that came before including Whisper, Secret,
Snapchat, and Confide.
Just evoke memories of sleepover parties and summer camp cabins. But just like in your
friend’s basement, where you might speak more freely amongst friends as you gaze
upwards at the ceiling, telling who’s who in our app isn’t as hard as you think. Our app isn’t
Secret, where a revealed identity could very likely cost somebody their job.
In addition to the above situations, there are a lot more situations where people’s right to
speak anonymously need to be protected. The issue of anonymity on the internet is an
important one and establishing such an environment is also important for either formal or
informal purposes.
Moreover, Partner Finding is also an important feature for users to use. Many of us are
living far from our families. When moving to a new university, work we might not have a lot
of friends and families around us. There are times that you might really want to play a
game, go to a movie, go hiking or other fun activities, but due to limited number of friends
around us, we find ourselves alone in doing all these activities. So partnerFinding is a
preliminary implementation of such application. You can post an event, like playing tennis
or going to SpiderMan and give some details of when or where you want to meet people
and people can join you. Since this is a preliminary implementation of this feature a lot of
functionalities can be added to it in future works.
1

2. A complete implementations of our solution can be used by large communities such as
universities or other organizations and it can include many sub parts. While it can include
anonymous chat for providing more freedom in expressing your ideas, it can also include
other features which can be used by members of that community. Currently two parts of it
have been initially implemented which embraces anonymous chat/vote and partner finding.
There can be other extensions added to this application.
2.Our Solution
Demo : https://www.youtube.com/watch?v=78IWUoJe5vc
https://www.youtube.com/watch?v=vDJuWruUc40
Our slogan of the app is “TURN OFF THE LIGHTS". In view of the above situations, our
goal is developing an app that will help users express their thoughts without displaying their
identities.
This kind of space — which is anonymous, yet personal — doesn’t really exist in the world.
Google Cloud platform will always know who is really talking in the chatroom. So for our
app, which runs on Android that lets you carry out anonymous group chats with friends. The
idea sounds like an oxymoron, but is more nuanced than you might think. Instructor(who
creates the chatroom) can share the name of the room to everyone but everybody inside
the chat window itself remains nameless, designated only by different colored regarding to
the initial characters of what they said. In other words, you’ll probably know which ten
friends are in your chat, but you won’t know who’s saying what. Or it may be the scenario
like the instructor knows that all the students within the class have already joined the
chatroom but doesn’t know who is speaking. The more people there are in the chat, the
less likely you’ll know who’s who.
We perfectly combine Chat/Vote and Partner Finding together. For instance, a Columbia
student Leon Lu wants to join an event sharing sexual experiences and techniques or how
to prevent sexual assaults in
Columbia.(http://www.nytimes.com/2014/04/25/nyregion/accusations­over­assault­at­colum
bia.html?_r=1) But before joining the event, Leon doesn’t want others know that he goes to
this event because he is too shy to let his friend know that he needs to improve his sexual
techniques. In fact, only people did go to the event will know who exactly attended the event
at the event site. Unlike Facebook event which will indicate who is going to attend an event
publicly or maybe going to an event. This app will allow users remain anonymous until
he/she actually shows up. What’s more, during the event, instructor wants to have a very
sensitive discussion with all the students in the classroom. Attendees can use this app to
say whatever they want using the app.
2

3. 3.Implementation
The implementation of our app is divided into two part : Chat/Vote and Partner­Finding.
Since both parts have heavy interactions with the Internet, we must provide a robust and
reliable front­end/
back­end
architectures. At first, we were choosing between several well
known backend­service
providers, such as Amazon EC2, Google App Engine or Heroku
etc. After analysing the pros and cons of all possible candidates, we finally decided to
choose the Google Mobile Backend Starter (abbreviated to MBS in later context) as our
backend server. The MBS is a backend interface provided by google to support those who
don’t have the resource/technique to set up a server while a properly set up server is a
critical component in their app. The underlie server of MBS is actually the Google App
Engine. MBS can be treated as a simple pre­built
version of Google App Engine, which
supports strong apis for put/extract entities to/from the cloud through several lines of api
calls from the client side. Besides, rather than coding in an unfamiliar server environment
and dealing with so many server side implementations, MBS provides the mobile
developers an off the shelf server as a service while retaining the flexibility and scalability of
the server if the business scale is going to another level.
The following are the basic ideas of how we take advantages of this pre­built
app engine.
Noticing the fact that our app is event/chat­room
based, we first came up with a method of
mapping our event/chat­room
into a CloudEntity. (A brief deviation here, a CloudEntity is a
row of a table in the cloud, which allows developers to customize their columns names and
corresponding values, for instance the following code demonstrates of how to put “123” in
the “sid” column in a table called “Student” :
CloudEntity student = new CloudEntity(“Student”);
student.put(“sid”, “123“);
// backendProcessor is an instance of Class that takes cares of backend
// requests/responds
backendProcessor.insert(student, taskFinishCallback);
)
We used the same idea to implement our event/chat­room.
We define every event/room as
a table, and all messages and functions are records. Let’s see another example of how to
separate chat and vote functions in one room (same CloudEntiy) :
3

4. // This section of code illustrates of how to put things to the cloud
CloudEntity room = new CloudEntity(“Room1”);
// We use api to separate different features in a room
// There are several apis, ex : chat, vote etc
if(isChatting){
room.put(“api”,”chat”);
room.put(“message”, “hello everyone”);
}else if(isVoting){
room.put(“api”,”vote”);
room.put(“voteDetails”, “Vote for fun”);
}
backendProcessor.insert(room, onTaskFinishCallback);
// This section shows how to get things from the cloud
OnTaskFinishCallback onTaskFinishCallback = new OnTaskFinishCallback{
public void onTaskFinish(List<CloudEntity> result){
// this function will be called along with the result when the query is done.
}
}
backendProcessor.query(“Room1”, onTaskFinishCallback);
Above are just the idea of of how the Android client communicated with the MBS. The
following part are details of Android side implementation.
● Overall architecture
Our app has two parts : chat/vote and partner­finding.
We designed a framework with
several dynamic fragments that best presents these two features.
4

5. As you can see, the transparent container in the middle is the fragment, you can swipe
left/right to access to different features.
● Chat/Vote implementation
For the chatting part. We have 2 options for every one that uses this app. The first page is
Enter a room. Ordinary users should type in the name of the room, which uniquely identifies
the room. We also did some abnormal check for entering the id of the room. For example,
if “Orange” has not been created, users cannot enter the room, as the following 2 pictures
show:
5

6. The second page is for instructors who creates a new room. Instructors just have to type in
the room name. We will also use new a CloudBackend() to do the check for the name of
the room. If the room has been created, then a error message will pop up which tells the
instructor that the room has been created before, as the 2 following pictures show(room
“Apple” has already been created, so the error page will pop up):
6

7. For the voting part, we first check whether the user is
ordinary user or instructor. If the user enters a room by
typing a name and press “enter”, then the user is an
ordinary user, so the user can’t vote. But if the user type in
a room name and then clicks“create”, then the user will
become an instructor and will have the permission to
raise a vote. (as the picture on the right side shows)
We only give the permission to instructor to raise a vote.
When the instructor clicks the “vote” button, a dialog will
pop out and let her do the voting. The voting mechanism
is actually quite intuitive. First the instructor will use that
pop out dialog to set up a vote, including title, details,
number of options and etc. Second, after the instructor
raised the vote, all other users in this room will receive a
pop out dialog showing the details and options of the
vote. All of the users have the right to vote for the options
or to waive their rights. And if they decide to vote for a
particular candidate, the result will be transmitted to the
instructor. The instructor, after receiving all the votes (she has the right to decide either to
keep waiting for more votes or calculate the result), can calculate the result and broadcast
the result to all the users in the room.
● UI/UX Design
In this part we’ll discuss about our UI design. First let’s discuss
the UI design in terms of the UI design heuristics.
According to the very first UI heuristic ­­Visibility
of system
status, while freezing the UI for some underlie tasks, we show
a progress bar indicating the user that the system is actually
working but not crashing. Besides, we also followed the
minimal design and aesthetic perspective, we put as less
information as possible in each page so that we won’t distract
the user from what’s really important. For instance, instead of
writing another title for the “enter the room” text field, we chose
to put the title inside the text field as a hint. This approach not
only reduced the use of space but also reduced the potential
confusion that might affect the users’ experience. In terms of
7

8. designing the fragment pager, we chose a barely visible container in order to hint the user
the existence of the fragment in a non distracting way, therefore the user would be aware of
the manipulability of the container. On the bottom of the container, there is an image saying
“Swipe right to enter a room” with a picture of a hand swiping from right to left. This helps
the user to recognize how to interact with our UI instead of making them to memorize it,
which is also an important thing to think about.
In terms of the implementation point of view, we use the ViewPager of the Android support
v4 library. The ViewPager basically takes care of adding and removing fragments. We
designed our tasks in a modular manner so that every task can be handled by one single
fragment, and since the dynamic of the ViewPager, it is easy for us to add more
functionalities later in the future.
● Partner finding Implementation
For CreateEventActivity class ,GUI created and for functionality CloudBackEndAsync class
and its methods are used to subscribe for
subscribing for cloud messaging and inserting the data to the schema at cloud storage.
For EventListActivity, We used CloudQuery class instance to fire a query to data base and
CloudBackendAsync class to retrieve the list of events. On clicking any item in the list ,it
show the details about the event.
Projects starts from a launching activity which is SelectionActivity and it is defined as
Launcher activity in menifest file. Here there are two buttons :1.for creating events 2.Find
partner for any event from available list. On clicking create button, CreateActivity activity
opens with all related fields. Here we have two buttons,either create an event or cancel it.
On clicking create button,it checks for all values input and then create
CloudBackendMessaging object and subscribe for cloud messaging. Creating CloudEntity
instance and add all properties to it. Sending the message using sendCloudMessage()
method of CloudBackendMessaging class.
Now the second button in SelectionActivity is to find partener:
On clicking the button controller goes to EventListActivity activity, where in onCreate()
query is created with CloudQuery class instance and order and scope is passed to it. After
creating query ,using CloudBackendAsync class instance, list() method of the same class
is called which returns list of events from cloud storage. As it returns the list, we call a
method named as deleteEvent() method to check for date of events and if any event exist
with the date which is already passed,then a new thread is initialized to delete that event.
Inside the thread delete() method of CloudBackendMessaging class is called using the
same class instance. And,also that event is removed from the list which is returned from
8

9. server. Here, EventListAdaptor,which is a custom list adaptor, called to generate the list. In
EventListAdaptor, getView() method is responsible for creating a list item view.Here, item
click listener is added to complete row. When an item is clicked ,all relevant data to the row
are passed to intent and hence to next activity which is ShowEventActivity. Finally the event
data are displayed in this activity.
In essence, PartnerFinding stores every event content including event date, host’s name,
event detail, etc. Sync all event to every phone automatically in a very short period of time,
ie. less than a minute. Sort the event in a list by hosting date, and will be updated when the
events are passed. It will be clearly indicate what happens in runtime. For example, when
the backend finish uploading the request data(event detail), it will toast a message to
indicate the back processing status.
4.Conclusion
To conclude, the main goal of this app is to let the users chat and find their partners
anonymously. Since nowadays one of our most important assets, the identity, is prone to
be abused by the transparency of the Internet, we should’ve provided it a protection shell.
Our app is that shell. We focus on casual anonym, which eases your life starting from your
daily perspective. By using our app, now you can join the meetings that you weren’t dare to
try so just because of you were afraid of exposing your participance of that event. With our
app, now you can express your true thoughts among your friends or agree/disagree with
your manager in a private room for your product team without worrying about the “price” of
saying your true opinions.
Although for now it’s just in the basic phase of the app, we believe in time our app will be a
great help for others.
5.Future
● Add a random delay of time to push message on the chat board
● Encode the message by RSA to make the messages perfectly secure
● In partner finding many fun additional functionalities can be added. When
the host specifies the number of required people to play a game with,
people can join, the number can be dropped with every one person joining
the event and can increase up to the required number when people leave
the event.
9

10. ● It may allow you to reserve a playground within the university when you are
posting the event.
6. Member Contribution
Allen: Anonymous Chatting and helping integrate Partner Finding part and report
Farzaneh Motahari: Developing Partner Finding application, preparing associated report
Leon Lu: Overall Design, Voting Part, UI design, integration of all parts and report
Marcus: Developing and Integrate Partner Finding part (UI & functions), and report
7.Reference
1.https://developers.google.com/cloud/samples/mbs/
2.https://cloud.google.com/developers/articles/mobile­backend­starter
3.https://developers.google.com/cloud/samples/mbs/deploy_backend
10