Gaia Hacks – Part 1

Following are some useful commands that i came across  while contributing to OPEN SOURCE  to  Mozilla  (Firefox OS)

All commands are used on Linux system (Ubuntu 14.04)

Hack – 1.  How to Run Gaia in your nightly browser

Install nightly browser in your system

  • sudo add-apt-repository ppa:ubuntu-mozilla-daily/ppa
  • sudo apt-get update
  • sudo apt-get install firefox-trunk

Getting the Source code

To get the source code for Gaia, fork us on GitHub and then clone your fork using git.This repo is around 1GB so have patience while clonning the repo.

$ git clone https://github.com/mozilla-b2g/gaia.git

Now go to your gaia directory.

cd gaia

After the above is complete, you are ready to make your local Gaia profile. Inside the gaia directory, which you should be in now, run:

DEBUG=1 make

The process above is going to do a bunch of things and the first time you run it, it is going to take some time so my suggestion is, take a break and make yourself some coffee. Once the above has completed the last line of output should be something like:

Profile Ready: please run [b2g|firefox]
-profile /Users/schalkneethling/mozilla/projects/gaia/profile

Now that we have our profile and nightly browser, let’s join the two. Open up a terminal (command line) and enter the following:This will open nightly browser and gaia running in browser 🙂

/path/to/nightly-browser -profile /path/to/profile

Something like this:-

rishav@rishav:~$ /usr/bin/firefox-trunk -profile /home/rishav/mozilla/gaia/profile-debug/ -no-remote
Screenshot from 2014-06-01 01:19:30

Hack – 2.  How to Update your forked gaia repo

Now another important thing.There is lots of changes takes place daily in master branch of mozilla-b2g/gaia repo.It’s not necessary for running gaia but it’s good if you update your forked gaia repo daily so that you will get updated with new changes.

git remote add upstream https://github.com/mozilla-b2g/gaia.git

Then run ‘git remote -v‘  you should see four lines, two called ‘origin’ (your fork) and two called ‘upstream’ (the mozilla-b2g original repo).

then, fetch from upstream repo:

git fetch upstream

Wait until gets all the changes, then go into your master branch (if you are not) and update it with the upstream master branch

git checkout master

git merge upstream/master

Once you have done that do ‘git push – -all‘  to push the updates into your fork (origin).

Hack – 3.  How to Run gaia unit-test

First of all what is unit test? 🙂

As part of the Gaia/B2G source code, we have  various unit tests available to run, for testing different aspects of Gaia and B2G.

Install nodejs and npm in your system.

The first thing you will need to do is open two terminals and go into main gaia directory in both terminals.

Now we need to set an environment variable to point to nightly firefox into both terminals.

We can do this by following command :

export FIREFOX=/path/to/your/nightly/firefox

Basically the FIREFOX environment variable has to point to nightly firefox binary.

Now after done with this, run following command in one of the terminal:

./bin/gaia-test

This will download a bunch of things and open the nightly browser.Now we are ready to run the unit test.

Now go to other terminal and run this command.This will run the unit test for SMS app.

make test-agent-test APP=sms

You can do this with any app whether it is contact, setting, calendar, sms etc….

If you run   ‘make test-agent-test‘    it will run unit test for all the app i.e complete gaia.

Best thing, once you start the unit test for any app (say sms), then if you make any changes in the code related to that app it will run the unit-test automatically and also very quickly 🙂

If you feel any problem then ping on irc channel #gaia or #b2g or join the gaia mailing list. You can ping me too on rishav006@gmail.com .

More blogs are coming on this till then

Happy Hacking  🙂

 

 

 


			

Gsoc_weekly_report_3

Finally official coding period of Gsoc 2014  began from 21st may. First part of my gsoc project is  Bug 829820 Ability to mark selected SMS threads as read https://bugzilla.mozilla.org/show_bug.cgi?id=829820. After a long discussion ,i think around one month, We arrived at important conclusions. As new features is landing for  SMS app, we planned to redesign new UI-flow  for SMS app.Thanks to Omega who designed the new UI-flow and my mentor Gabriele Svelto  who suggested more  changes and planned how to carried out these changes.

Finally me and my mentor decided to split this bug into smaller one so that it will become easy to track all the changes.

The idea would be to split it in the following bugs:
- Refactor the existing edit mode to use Omega's proposal 
  but w/o additional features (i.e. delete only),this would include 
  the thread edit mode too (UI should be rather compatible).
- Add mark-as-read mode to the thread list edit mode.
  From here i am extending my gsoc project.
- Add undo for both delete and mark-as-read in both modes.

I worked on the first section in this week.I refactor the existing edit mode to use Omega’s Proposal but without additional feature (i.e delete only), this would include the thread edit mode too.Apart from these i added select all and deselect all in one button.When we select all threads then it will show ‘deselect all’  button, other wise it will show ‘select all’  button.All codes are in my github forked repo.Link of the patch for this first section https://github.com/kumarrishav/gaia/compare/sms-interaction

Below are some screen shots of SMS app after landing this patch

.
Screen Shot 2014-05-03 at 04.55.46 Screen Shot 2014-05-03 at 04.55.50 Screen Shot 2014-05-03 at 04.55.56 Screen Shot 2014-05-03 at 04.56.00 Screen Shot 2014-05-03 at 04.56.04 Screen Shot 2014-05-03 at 04.56.07 Screen Shot 2014-05-03 at 04.56.14

 

 

How to build B2G emulator in Linux Environment

Before obtaining the code to build Firefox OS, you need a properly configured build system — this page shows you how. You can currently build on 64-bit Linux distributions .I built the B2G emulator on Ubuntu 14.04 (64-bit).Steps given here are same like in MDN, except few changes.

64 bit requirement installation

With Ubuntu 14.04, multi-arch packages are now the main way to support multiple architectures (e.g. 32-bit on a 64-bit install).  You must tell your Ubuntu system that you want to support 32-bit packages as well:

sudo dpkg --add-architecture i386
sudo apt-get update

Once you’ve completed that, then you can install the necessary packages:

sudo apt-get install --no-install-recommends autoconf2.13 bison bzip2 ccache curl flex gawk gcc g++ g++-multilib gcc-4.6 g++-4.6 g++-4.6-multilib git lib32ncurses5-dev lib32z1-dev zlib1g:amd64 zlib1g-dev:amd64 zlib1g:i386 zlib1g-dev:i386 libgl1-mesa-dev libx11-dev make zip libxml2-utils 

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.6 1 

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 2 

sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.6 1 

sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 2 

sudo update-alternatives --set gcc "/usr/bin/gcc-4.6" 

sudo update-alternatives --set g++ "/usr/bin/g++-4.6"

Emulator build issues

If you are making an emulator build, you need to pay attention to these issues:

First, note that you shouldn’t use the x86 emulator — it is hard to install and not well supported.

Next, the build-system for the emulator builds both 32bit and 64bit versions of the emulator. As the emulator depends on OpenGL, this means that you need to have both 32bit and 64bit versions of OpenGL libraries installed on your system. See the discussion in bug 897727.

Way that you can solve this problem:

If your linux distro has multilib packages for OpenGL libraries, you can attempt installing them. You might then have to manually create some symlinks.

For example, here is the situation on Ubuntu 12.04 LTS x86-64. On this distribution, the libgl1-mesa-dev package cannot be installed simultaneously in x86-64 and i386 versions, but you can have the following combination of packages simultaneously installed:

sudo apt-get install libgl1-mesa-dev libglapi-mesa:i386 libgl1-mesa-glx:i386

After having run this command, you will still have to manually create some symlinks for the emulator build to succeed:

sudo ln -s /usr/lib/i386-linux-gnu/libX11.so.6 /usr/lib/i386-linux-gnu/libX11.so
sudo ln -s /usr/lib/i386-linux-gnu/mesa/libGL.so.1 /usr/lib/i386-linux-gnu/libGL.so

Clone B2G repository

The first step, before you can start your first build, is to clone the B2G repository. This will not fetch everything! Instead, it will fetch the B2G build system and setup utilities. Most of the actual B2G code is in the main Mozilla Mercurial repository.

To clone the repository, use git:

git clone git://github.com/mozilla-b2g/B2G.git (or git clone https://github.com/mozilla-b2g/B2G.git)

After cloning (which should only take a minute with a fast connection), cd into the B2G directory:

cd B2G

Till so far it was exactly same as what’s given in MDN.Now here are some changes.May be some of you are behind college firewall, Codeaurora.org and some other repo won’t allow to get the codes (Details are here : https://bugzilla.mozilla.org/show_bug.cgi?id=979986). So my mentor Gabriele Gsvelto came up with a good solution.We did some modifications in Xml files of B2G repo.Only thing you have to do is to use this patch.That’s it.We are done. 🙂  Really i struggled a lot for this.So, i thought to share with you guys.May it help you in future.Thanks to my mentor who came up with such a great solution.

Once you’ve retrieved the core B2G build system, you need to configure it for the device on which you plan to install it. To get a list of supported devices, you can use the config.sh utility — run the following command from within the B2G directory:

Now run this command :

env BRANCH="bug-979986-https-only" GITREPO="https://github.com/gabrielesvelto/b2g-manifest" ./config.sh emulator

Time for coffee break 🙂 To build Boot to Gecko, simply use the build.sh tool.This will collect all the necessary code for building b2g emulator from various repos.So you don’t need to get those from all repos one by one. Whole procedure gonna take long time.If your internet connection is good, still i may take 3-4 hours.It’s around 12 GB 🙂 Next step is to build the emulator.

To build Boot to Gecko, simply use the build.sh tool

cd B2G
./build.sh

Time for another coffee break, or possibly a nap (especially if this is your first build).

FInally we are done 🙂 cheers  🙂

Starting the emulator

To start the B2G emulator, type the following command:

./run-emulator.sh

This will handle all the emulator startup tasks for you. Now wait patiently while the emulator starts up and Boot to Gecko boots up on it. It can take a couple of minutes, so be patient.

Screenshot from 2014-05-19 08:16:56

Now you are thinking what is the use of doing all this, we can do same in simulator or in gaia (running in Nightly browser). Nope, there are some functionality that you cannot simulate on above stuff.So to simulate those functionality like Hardware Events Emulation, Telephony Emulation,SMS Emulation and much more  you need b2g emulator.

Using the Emulator Console


Each running emulator instance provides a console that lets you query and control the emulated device environment. For example, you can use the console to manage port redirection, network characteristics, and telephony events while your application is running on the emulator. To access the console and enter commands, use telnet to connect to the console’s port number.

To connect to the console of any running emulator instance at any time, use this command:

telnet localhost <console-port>

An emulator instance occupies a pair of adjacent ports: a console port and an adb port. The port numbers differ by 1, with the adb port having the higher port number. The console of the first emulator instance running on a given machine uses console port 5554 and adb port 5555. Subsequent instances use port numbers increasing by two — for example, 5556/5557, 5558/5559, and so on. Up to 16 concurrent emulator instances can run a console facility.

So open up a new terminal and type this command

telnet localhost 5554

It will show results something like this in your terminal  

rishav@rishav:~$ telnet localhost 5554
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Android Console: type 'help' for a list of commands
OK

Bingo you did this! cheers 🙂 Now you can test stuffs by writing commands in same terminal.Some of the examples i have shown below :

SMS Emulation

The  emulator console lets you generate an SMS message and direct it to an emulator instance. Once you connect to an emulator instance, you can generate an emulated incoming SMS using the following command:

sms send <senderPhoneNumber><textmessage>

For ex :  sms send 12345 hello b2g

Screenshot from 2014-05-19 08:27:25

Telephony Emulation

The emulator includes its own GSM emulated modem that lets you simulate telephony functions in the emulator. For example, you can simulate inbound phone calls, establish data connections and terminate them. The system handles simulated calls exactly as it would actual calls. The emulator does not support call audio.

You can use the gsm command to access the emulator’s telephony functions after connecting to the console. The syntax for this command is as follows:

gsm <call|accept|busy|cancel|data|hold|list|voice|status>

For ex : gsm call 12345
Screenshot from 2014-05-19 08:28:05


Stuck somewhere? Got any problem! Feel free to ask either on irc channel (#b2g, #gaia) or in dev-gaia/dev-b2g  mailing list.
You can ping me too (comment here or mail me : rishav006@gmail.com).Happy to help 🙂
Till then HAPPY HACKING ! 🙂 🙂

Gsoc_weekly_report_2

Last week went slow, I could n’t do much work on my project.I had my end semester exams  so most of time got passed for preparation of my papers.Finally exam went well and got over on 16th may.Now no more exams for at least 3-4 months.But Still during examination too i managed to get some time for one of my difficult task :- building emulator and yeah 🙂 i finally built the b2g emulator.Also, we discussed UI-flow for Bug https://bugzilla.mozilla.org/show_bug.cgi?id=829820       Cheers !!! 🙂 🙂

My mentor ‘Gabriele Svelto’ helped me a lot in building the b2g emulator.Firstly i thought i will be easy to built the emulator as i have to follow steps given in MDN.But actually it was little bit difficult.I faced a few problems.

First problem was, i was working on 32 bit linux.We tried (me and my mentor) to built the emulator but got many errors and built failed.We tried so many to things but still problem remained same.After debugging for a long time, we finally move on to 64 bit linux system.

Second one, as i was behind firewall (college network), i faced difficulty in clonning the codes from codesaurora.org(to built B2G it uses some android codes too which is in codeaurora.org repo) because it was refusing http/https connection.

Following errors were coming:

remote: Counting objects: 60866, done.
remote: Compressing objects: 100% (19029/19029), done.
fatal: unable to connect to codeaurora.org:5 MiB | 732 KiB/s    

codeaurora.org[0: 198.145.11.235]: errno=Operation timed out
fatal: unable to connect to codeaurora.org:
codeaurora.org[0: 198.145.11.235]: errno=Operation timed out
fatal: unable to connect to codeaurora.org:
codeaurora.org[0: 198.145.11.235]: errno=Operation timed out

remote: Total 60866 (delta 34102), reused 60510 (delta 33747)
Receiving objects: 100% (60866/60866), 64.76 MiB | 839 KiB/s, done.
Resolving deltas: 100% (34102/34102), done.

But finally i got the solution with the help of my mentor.

In next blog : Detailed steps to build B2G emulator and how to simulate various functionality on it.

https://rishav006.wordpress.com/2014/05/19/how-to-build-b2g-emulator-in-linux-environment/

Till then Happy Hacking !  🙂