Now you can Subscribe using RSS

Submit your Email


Login with Facebook in Android App - Tutorial & Source Code

Vishal Shrestha

If you have an app that required user login, providing Facebook login in your Android App can be an easy and convenient way for both your user and you to implement login. Now a days we can see lot of web and mobile apps provide an option to Login with Facebook along with the general email and password login. Most people already have a Facebook account and it's easy to just login using Facebook rather than to first register using email and password. This has become more of a common trend because of how easy Facebook has made integrating Facebook Login in your Android App or any app for that matter. So integrating Facebook Login in you App is a win-win situation for both you and your users.
Let's begin with latest Facebook's SDK for Android, it should take only a few minutes to add this feature to your app. After the basic login, we will also see how we can get the Facebook Profile Picture in our Android app and other profile details like email, date of birth, name and more.

This we will cover in this tutorial:
  1. Creating a new project and registering it in Facebook Developers for Facebook Login.
  2. Integrate Facebook Login in our Android App.
  3. Get User profile detail like User ID, Profile Picture, Email, First Name, Last Name and more.
Note: By Default, when you perform Facebook Login in you Android App, the you can access some details like :  id, cover, name, gender, profile picture and few more. You don't to do any more requests to get the mentioned details, however if you need to access other details like Email you need to define those properties while you login, so that Facebook can ask if you want to allow an app to access those properties. You'll notice in our app that we explicitly define we need Email, so that Facebook can let you know the app will access your Email. You can check out more details in Facebook's official Page: Facebook Login Permissions

  1. A Facebook Account to test login.
  2. Installed Android Studio on your laptop or PC.
  3. An Android Device.

So let's begin!

Adding Facebook Login to our Android App:

  1. Create a new Android App.
  2. First of all, let's open up Android Studio and create a new App. Let's call the app myloginapp. After the app is created we don't need to write any code at the moment. Just keep in mind or copy the package name from Manifest file or App level Gradle file. We will need the package name of the name when we are registering the App for Facebook Login.

  3. Add the App in Facebook developer page.
  4. 1

    Now that we have our Android App's package Name, we can go to Facebook Developers Page and Register our app and integrate Facebook Login. Go to: Facebook for Developers You'll see a page similar to this:
    Register Android App for Facebook Login

    Now click on the create new app button and enter the package name of your Android App. It will show a warning that the App cannot be found on the Play Store, click on add the app anyway as we are just building our Android app. Now we have successfully added our Android App for Facebook Login, we just need to add hash, we'll do that is the following sections.

  5. Add necessary Dependencies.
  6. Now if you scroll down you'll find adding dependencies section like this:
    Facebook Dependencies for Android App
    We need to include these dependencies to use the Facebook SDK for Android. The Facebook SDK contains methods and callback that makes Facebook login integration very easy in an Android App. Add mavenCentral() in project level repositories section and and the dependency "compile '[4,5)'" in App Level Gradle File. You Project level Gradle file should look like this: And App level Gradle file should look like this.

  7. Add App ID to strings.xml and edit Manifest file.
  8. Now you'll need to add your Facebook App Id and protocol scheme in strings.xml, inside values folder. If you scroll down on the developer's page you can find you APP ID and Protocol Scheme. After adding the dependencies, you will need to add you APP ID in strings.xml inside values folder. App ID is unique for each app and it will identify your Android App uniquely.
    Facebook App ID
    Copy them and paste it in your strings.xml. If you have strings.xml corresponding to multiple languages, paste it in all the strings.xml. Now open you manifest.xml file. We need to add the internet permissions for obvious reasons and also meta-data required for Facebook Login, do not forget this as the Login won't work without this. So add internet permission: "<uses-permission android:name="android.permission.INTERNET" />" As you're app will need Internet connection for Login. Finally you'll need to add a meta-data and the default FacebookActivity. You can copy the meta data from the code below or Facebook Developers page. The Final manifest.xml should look like this:

    <manifest xmlns:android=""

        <uses-permission android:name="android.permission.INTERNET" />

                android:value="@string/facebook_app_id" />

                android:label="@string/app_name" />


  9. Generate and add Key Hash.(Link to Download SSL)
  10. Now scroll down on the Facebook Developers page and you'll see a section that looks like this:
    Associating Package Name
    This is the Final Part of App registration. We can start coding after this. Enter your package name that you had entered earlier in step 2. In the default Activity class name, enter your package name followed by .MainActivity
    We don' have an activity created yet so now we'll have to name our launcher Activity MainActivity. Finally, if you scroll down a bit more you'll see a section that requires Key Hash, for development you'll need to get your debug key hashes. Use the following commands to get key hashes.
    On Windows: keytool -exportcert -alias androiddebugkey -keystore %HOMEPATH%\.android\debug.keystore | openssl sha1 -binary | openssl base64
    On Mac: keytool -exportcert -alias androiddebugkey -keystore %HOMEPATH%\.android\debug.keystore | openssl sha1 -binary | openssl base64
    In windows the HOMEPATH is usually C:/Users/Username.
    If you are having problems like Command keytool not recognized, you'll need to go to your Java installation directory and run the command from inside the bin folder. If you are having problems with the ssl command, you'll probably need to install SSL, refer here if you have problem with SSL command: OpenSSL Issues.

  11. Create Facebook Login Activity Layout.
  12. Now finally we can do some code. We have successfully registered our Android App to Facebook, added the required dependencies and modified the Manifest file appropriately. Now let's write some code. Switch to Android Studio and create a new layout file. Name it activity_main.xml. We will add the default Facebook Login button provided by Facebook Android SDK. The Default Facebook Button looks like this:
    Default Facebook Login Button for Android app
    The Layout is pretty simple and should look like this: main_activity.xml
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android=""

            android:text="Connect with FB"
            android:layout_marginTop="30dp" />


    The default text on the button is Connect with Facebook. To change the text on the Button we need to add this in LoginButton:
    facebook:com_facebook_login_text="Your Login Text"
    To change the Text for logout add the following code to the button facebook:com_facebook_logout_text="You Logout Text"

  13. Create Facebook Login Activity Java File.
  14. Now Create a new java file and name it We will do following things in this class:
    • Add Reference to the Facebook Login button.
    • Initialize a callback Manager to get Login Request Result.
    • Register the callback Manger with Facebook Login button.
    • Call the Callback Manager in onActivityResult.
      Here's what you should look like:

    public class MainActivity extends AppCompatActivity {

        LoginButton loginButton;
        CallbackManager callbackManager;

        protected void onCreate(Bundle savedInstanceState) {
            loginButton = (LoginButton) findViewById(;
            callbackManager = CallbackManager.Factory.create();
            // Callback registration
            loginButton.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
                public void onSuccess(LoginResult loginResult) {
                    // App code
                    Log.d("mylog", "Successful: " + loginResult.getAccessToken());
                    Log.d("mylog", "User ID: " + Profile.getCurrentProfile().getId());
                    Log.d("mylog", "User Profile Pic Link: " + Profile.getCurrentProfile().getProfilePictureUri(500, 500));

                public void onCancel() {
                    // App code

                public void onError(FacebookException exception) {
                    // App code
                    Log.d("mylog", "Successful: " + exception.toString());

        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            callbackManager.onActivityResult(requestCode, resultCode, data);

    Now if the Facebook Login is successfully added, you should be able to see Access token, User ID and Link to Facebook's Profile Picture in the log.The code is pretty simple, we are just getting reference to Facebook login button then setting email read permission and the registering the callback manager. Don't forget to include the onActivityResult, as that part triggers the callback manager. If you just want a secure login, then we are done, we've successfully integrated Facebook Login to our Android App.

  15. Perform Graph Request to get User Details like Email and Birthday.
We now have successfully logged in, but what if we need more user details. It's always good to greet the user with a Happy Birthday message in your app. So in order to get more details, we utilize the graph request feature of the Facebook SDK. It's pretty simple you just define what you need to read from the Facebook Profile of the User and execute the request. Add this performGraphRequest method to you and call it from the onSuccess method of the FacebookCallback that you had registered with Facebook Button in the previous step: Here's the performGraphRequestMethod:

private void performGraphRequest(LoginResult loginResult) {
        GraphRequest request = GraphRequest.newMeRequest(loginResult.getAccessToken(), new GraphRequest.GraphJSONObjectCallback() {
            public void onCompleted(JSONObject json, GraphResponse response) {
                // Application code
                if (response.getError() != null) {
                } else {
                    String jsonresult = String.valueOf(json);
                    Log.d("mylog", "JSON Result" + jsonresult);

                    String fbUserFirstName = json.optString("name");
                    String fbUserEmail = json.optString("email");
                    String fbBirthday = json.optString("birthday");
                Log.v("FaceBook Response :", response.toString());
        Bundle parameters = new Bundle();
        parameters.putString("fields", "id,name,email,gender, birthday");

So we are requesting more of the user details when the user is successfully logged in to your app using Facebook. Here's the performGraphRequest method: We are done, now just run the App in your Android Phone and test it. You should be able to see the user details in the Logs. Use it creatively. This marks the end of this tutorial, if you have any problems just let me know in the comments below, excited to see what you build! Happy Coding.
Download the full source code: Facebook Login Integration in Android App.


Firebase Cloud Messaging (Notifications) in Android App full tutorial

Vishal Shrestha
Firebase is a valuable tool for developers that helps you to integrate many services like cloud messaging, authentication, realtime database, storage, crash reporting and much more . You might have already used some services from the vast pool of services that Firebase provides, and in this post we will discuss how we can add our project to Firebase and Integrate it's cloud messaging service in our Android App. Topics discussed in this tutorial are:
  1. How to add an Android Project to Firebase Console.
  2. How to Integrate Firebase Services(Cloud Messaging)in our Android app.
  3. How to Send Notification to the app from Firebase console.
  4. How to handle Received notification and Notification data in our app.
The first step is to create a project in Android Studio and add it to Firebase Console. So let's get started:
If you already have an Android Project in which you want to add Firebase, you can skip the section below that shows creating a new project in Android Studio. For beginners, here's how you create a project:

You can also check out the our YouTube tutorial here: Integrating Push Notifications in Android using Firebase Cloud Messaging.
Creating a new project in Android Studio:
  1. Open Android Studio then from the Navigation Menu select File->New->New Project. 
  2. Name the new project named FirebaseRealtime and click next. 
  3. Now select a minimum SDK version of your choice, I've selected 5.1. 
  4. After a minimum SDK selection click on next and select Add no Activity and click finish. You've successfully created an Android Project.

Adding the project to Firebase

Once you have your project ready, It's time to add the project to firebase. Open the app-level gradle file of your project and copy the application package name. We will use it to add our project in Firebase. Check the highlighted section in the Image below for reference:

In the image above, the application package name is is com.thecodecity.firebaserealtime. Copy the package name and go to Firebase Console. You can login with your Gmail account.
Once you are logged in you should see a screen like this:


Now click on add project and enter any name and click next. You have your project ready. Now you should be in your project console and it will look similar to this:


Notice the scroll bar at the left side, it contains many options and once you scroll down you'll see a notifications option. Click on it, a dialog box will pop up asking for package name, app nickname and SHA1. It should look similar to this:


Everything except the package name is optional. Now paste your package name that you had copied earlier and click on register app. Now you should see another dialog with option to download json. Download the json file and copy it in the app directory of your project.

Integrating Firebase in Android App

Now that we have added the Json file in our project and added our app in Firebase console, It's time to integrate Firebase in our Android app. First of all we need to add dependencies so that we can use classes and Methods provided by Firebase. In your project level Gradle file add the following dependency as highlighted in the figure below.
classpath ''


Now in your app level Gradle file, add the following dependency as shown in the figure below:
compile ''

Now add this: apply plugin: '' to the bottom of the file as shown in the image above.
Voila, finally we are now ready to write some code!
We need to create two services, one to get the refreshed token and other to handle notification that the app will receive. The refreshedToken is actually a device registration ID that Firebase generates that uniquely identifies a device. It can be used to send notification to a particular device from the vast pool of devices in which your app is installed.
Let's get started and create the first service. Name it Here's the code:

public class MyFirebaseInstanceIDService extends FirebaseInstanceIdService {

    String refreshedToken;

    public void onTokenRefresh() {
        Log.d("mylog", "Inside on token refresh");
        //Getting registration token
        refreshedToken = FirebaseInstanceId.getInstance().getToken();
        //Displaying token on logcat
        Log.d("mylog", "Refreshed token: " + refreshedToken);

In the code above we are not doing anything important, just displaying the token in the log. In real world applications it can be stored in a database in a server and later it may be used to send individual personalized notification to the device. The Token is refreshed only once when the app is installed in the device. So you will not be able to see this log more than one unless you uninstall and reinstall your app or clear the data of your app from settings. You can later access this token using: FirebaseInstanceId.getInstance().getToken();

Now let's create our second service, name it Here's the code for the class:

public class MyFirebaseMessagingService extends FirebaseMessagingService {

    public void onMessageReceived(RemoteMessage remoteMessage) {
        // Not getting messages here? See why this may be:
        Log.d("mylog", "From: " + remoteMessage.getFrom());


In the onMessageReceived method, we get a remoteMessage object that contains notification details like title, body and data payload. We will discuss it in detail in the next section. However our app is ready to receive notifications.

Receiving Notification and Data Payload in App

Till now, our app can just receive notifications without any other data. Now let's do a little more and handle data other than just title and body as well. Keep in mind you can access this data only when you receive a notification when you app is in the foreground. We already have our MyFirebaseMessagingService class, just add the following lines of code in the onMessageReceivedMethod:

// Check if message contains a data payload.
        if (remoteMessage.getData().size() > 0) {
            Log.d("mylog", "Message data payload: " + remoteMessage.getData());
        // Check if message contains a notification payload.
        if (remoteMessage.getNotification() != null) {
            Log.d("mylog", "Body: " + remoteMessage.getNotification().getBody());
            Log.d("mylog", "Title: " + remoteMessage.getNotification().getTitle());

        String message = remoteMessage.getData().get("message");
        Log.d("mylog", "Message Payload: " + message);

        Intent intent = new Intent(getApplicationContext(), MainActivity.class);
        intent.putExtra("message", message);

Here, remoteMessage.getNotification().getBody() gets the body of the notification and remoteMessage.getNotification().getBody() gets the title of the notification. Other then that if there is more data, known as data payload we can access it using remoteMessage.getData().get("key"). Data payload is sent in key-value pair and values can be accessed using their key. In the code above, after the value of the key "message" is fetched, we start a new Activity with the message as extra. We don't have that Activity yet, so let's create a new Activity. First let us create a simple XML layout for the Activity. Name the layout activity_main.xml. Here's the layout code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""

        android:text="Message from Firebase Notification:"/>

        android:text="No Message"
        android:layout_margin="16dp" />


It's a simple layout that contains two TextViews. We will use one of the TextView to display the message sent in the Notification. Now let's create the Activity. Name it

public class MainActivity extends AppCompatActivity {

    TextView textView;
    protected void onCreate(Bundle savedInstanceState) {
        textView = (TextView)findViewById(;
        String id = FirebaseInstanceId.getInstance().getToken();
        Log.d("mylog", "Token: " + id);
        Intent intent = getIntent();

In this Activity we check the token for the device using FirebaseInstanceId.getInstance().getToken(); and display in in log. Then we check if the intent has an extra called "message". If yes, then we change the content of the textView to that message. When we first open the App, there will be default text shown in the textView but if we send a notification with data that contains the key "message". The message will be shown in the textView. Now we are all done. We just need to add the Activity and the Services that we created in the Manifest file and we are good to go. Put the following lines inside <application> tag:

   <service android:name=".MyFirebaseMessagingService">
                <action android:name="" />

        <service android:name=".MyFirebaseInstanceIDService">
                <action android:name="" />

        <activity android:name=".MainActivity">
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />

Also add the following permission outside of the <application> tag: <uses-permission android:name="android.permission.INTERNET"/>

We are now done! we can now run our app and test notifications by sending notification from the Firebase notification console. Go to Firebase Console, select your project and scroll the left side bar to the bottom and click on notification. You'll should now see a page similar to this:


The options are self explanatory, the message text is the description part of the notification that is displayed below the notification title, Message label is for you so that you can later find this notification using this label. In the delivery date you can choose to send now or send later on a specified date or time and finally you can choose a package name to which you need to send notification. Now you can scroll down and click send notification and you'll receive notification if your app is in the background. If you were attentive enough to see the advanced options button while scrolling down, clicking on that button will reveal some options looking like this:


The title option is self explanatory, it's the title of the notification that the users will see, Notification channel is a new feature since Marshmallow that allows sending notifications to certain channel within app like sports, news etc. Custom data allows to send extra data that can be retrieved using key value pairs. Try it out, minimize our app and send notifications. Open the app and send notification with key value pairs and you should see the contents of the TextView change. That's it, we have a fully functional app with cloud notification working. We will cover some more advanced stuff with Firebase Cloud Messaging in the next tutorial. If you have any issues, feel free to comment them below. I'll try to solve it to the best of my abilities. Cheers! happy coding.

SOURCE CODE: Firebase Cloud Messaging Android App


Send Email from Android App directly without Intent

Vishal Shrestha
Sending Email from an Android app is not difficult if you want to open up another Email App that handles sending the Email. We can just achieve that by adding an ACTION_SEND intent and we can also set content type and use extras such as EXTRA_EMAIL, EXTRA_CC and more. If we start this intent, all the apps that can handle emails such as Gmail app, default Email app will be shown in a chooser dialog if you haven't chosen a default already. Then your user can easily manage the creation and sending of the email from the third party app. But that's not always the case, some times we are required to send an Email from our own App with a fixed Email address to a specific Email address, for example if we need to send a password recovery link on the click of Forgot Password, recovery link to the user should be sent by email from within our app with our own Email Address. In this post we will learn how we can send Email directly from an Android App without and Intent. So let us begin.

Screenshot of final App of this tutorial

Steps in sending Email from Android App directly without Intent: 


  • We require 3 jar libraries for allowing us to send Emails, download the three libraries (LINK BELOW)
  • We create a JSSEProvider class.
  • We create a MailSender class that handles Authentication for our Email and sends Email directly without intent.
So now that we have the steps laid out, let's dig deeper on how to send Email Directly form our App, here's a sample video of the Email app that we will create:

Step 1
First of all download the 3 files- Activation.jar, Additional.jar, Mail.jar.
These are libraries that allow us to send Email in Java.
Once you've downloaded theses files, put it in the libs folder inside your app directory. If you don't have a libs folder inside your app folder, create one and place these files inside the folder.

Step 2
Now that you've copied the files in libs directory, it's time to include those libraries as dependencies. You'll need to do some changes in the app level Gradle file.  Add the following lines in you dependencies section:

compile files('libs/activation.jar')
compile files('libs/additional.jar')
compile files('libs/mail.jar')

Now you are done with libraries part and are ready to code the Email Sender App.

Step 3
Create a new class called JSSEProvider it should extend Provider class. JSSE provides a framework and an implementation for the SSL and TLS security and also provides some other functionalities like encryption and more. You can learn more about it here. Now add the following code in the class. Import all the required classes:

public JSSEProvider() {
        super("HarmonyJSSE", 1.0, "Harmony JSSE Provider");
        AccessController.doPrivileged(new<Void>() {
            public Void run() {
                put("Alg.Alias.SSLContext.TLSv1", "TLS");
                return null;

Step 4
Create a class that extends javax.mail.Authentication. I've called it Gmail Sender because I'll be sending Email from one of my Gmail account. Now add the following code in the class:

 private String mailhost = "";
    private String user;
    private String password;
    private Session session;

    static {
        Security.addProvider(new JSSEProvider());

    public GMailSender(String user, String password) {
        this.user = user;
        this.password = password;

        Properties props = new Properties();
        props.setProperty("mail.transport.protocol", "smtp");
        props.setProperty("", mailhost);
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.port", "465");
        props.put("mail.smtp.socketFactory.port", "465");
        props.put("mail.smtp.socketFactory.fallback", "false");
        props.setProperty("mail.smtp.quitwait", "false");

        session = Session.getDefaultInstance(props, this);

    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(user, password);

    public synchronized void sendMail(String subject, String body, String sender, String recipients) throws Exception {
            MimeMessage message = new MimeMessage(session);
            DataHandler handler = new DataHandler(new ByteArrayDataSource(body.getBytes(), "text/plain"));
            message.setSender(new InternetAddress(sender));
            if (recipients.indexOf(',') > 0)
                message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(recipients));
                message.setRecipient(Message.RecipientType.TO, new InternetAddress(recipients));
        }catch(Exception e){
            Log.d("mylog", "Error in sending: " + e.toString());

    public class ByteArrayDataSource implements DataSource {
        private byte[] data;
        private String type;

        public ByteArrayDataSource(byte[] data, String type) {
   = data;
            this.type = type;

        public ByteArrayDataSource(byte[] data) {
   = data;

        public void setType(String type) {
            this.type = type;

        public String getContentType() {
            if (type == null)
                return "application/octet-stream";
                return type;

        public InputStream getInputStream() throws IOException {
            return new ByteArrayInputStream(data);

        public String getName() {
            return "ByteArrayDataSource";

        public OutputStream getOutputStream() throws IOException {
            throw new IOException("Not Supported");

Now we have all the required this are we are ready to send Email from our app. We will just create one method in our Activity and call it whenever we need to send the Email to the User. This method will contain your Email Address, your password so you can be authenticated and the email address of your recipient. Let's call this methods sendMessage():

private void sendMessage() {
        final ProgressDialog dialog = new ProgressDialog(ActivityMain.this);
        dialog.setTitle("Sending Email");
        dialog.setMessage("Please wait");;
        Thread sender = new Thread(new Runnable() {
            public void run() {
                try {
                    GMailSender sender = new GMailSender("youremail", "yourpassword");
                    sender.sendMail("EmailSender App",
                            "This is the message body",
                            "your recipient's email");
                } catch (Exception e) {
                    Log.e("mylog", "Error: " + e.getMessage());

Finally we have our app ready and we can call this method whenever we need to send the Email directly from the app without any intents. You can find the full source code below, Cheers!

NOTE: Gmail has disabled logging in to accounts by third party apps. You need to disable this feature of Gmail and allow logging in from any app otherwise you won't be able to login and Emails won't be sent from your account.

Full source code for Email Sender App:Download Email Sender


Take screenshot and share to facebook using Unity for Android

Vishal Shrestha
In this post we will share the screenshot that we took using Unity's Application.CaptureScreenshot() Method 1. If you haven't check it out here's the post: Take Screenshot and Display using Unity.

In part 1 we took the screenshot using Unity and saved it in the local storage of the device. Now we will get that screenshot and send it to all the available apps like Facebook, Twitter, Instagram in your Android phone. Let's start the screenshot sharing process.

Share screenshot image of Hill Climb

Share screenshot to Social Media - Android Game

First of all we will start sharing once a share button is pressed. We are assuming you have a share button. Here it the function that will be called when you click on the share button. The isProcessing variable is a bool and it check if user has already pressed the share button and the screenshot is being shared now, if not then starts to share the screenshot. The startCoroutine(ShareScreenshot()) is the method doing all the work. StartCoroutine executes the method provided as parameter is a different thread. ShareScreenshot() function has the code to share the screenshot in Android.

On Share Button Press
  public void ShareBtnPress()
        if (!isProcessing)

Now, this is the main part. Here we have used AndroidJavaClass and AndroidJavaObject that can be initialized with the name of the class in Android along with its package. Check out the code below:

IEnumerator ShareScreenshot()

          isProcessing = true;

        string destination = Path.Combine(Application.persistentDataPath, "screenshotroadies.png");

        if (!Application.isEditor)
            AndroidJavaClass intentClass = new AndroidJavaClass("android.content.Intent");
            AndroidJavaObject intentObject = new AndroidJavaObject("android.content.Intent");
            intentObject.Call<AndroidJavaObject>("setAction", intentClass.GetStatic<string>("ACTION_SEND"));
            AndroidJavaClass uriClass = new AndroidJavaClass("");
            AndroidJavaObject uriObject = uriClass.CallStatic<AndroidJavaObject>("parse", "file://" + destination);
            intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_STREAM"),
            intentObject.Call<AndroidJavaObject>("putExtra", intentClass.GetStatic<string>("EXTRA_TEXT"),
                "Can you beat my score?");
            intentObject.Call<AndroidJavaObject>("setType", "image/jpeg");
            AndroidJavaClass unity = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            AndroidJavaObject currentActivity = unity.GetStatic<AndroidJavaObject>("currentActivity");
            AndroidJavaObject chooser = intentClass.CallStatic<AndroidJavaObject>("createChooser",
                intentObject, "Share your new score");
            currentActivity.Call("startActivity", chooser);

        isProcessing = false;

The above code creates an intent with the send action and puts the screenshot as an extra. If you are familiar with Intents in Android  this is probably simple for you to understand just by looking at the code.What we are doing is just initialize an Intent. Setting its action to ACTION_SEND. Creating a Uri object with the path of the screenshot to be shared. Passing the URI object as an Stream extra to the intent and then setting "Can you beat my score?" as a string extra and finally setting the type to image/jpeg. Then we are creating a chooser, this pops up all the available applications that can handle this intent. And we are done, now you have your share screenshot functionality complete in your Android Game. If you have any problem feel free to ask in the comments below. Happy Coding!


How to take Screenshot and Display in Game using Unity for Android

Vishal Shrestha
In this post we will learn how to take screenshot of the game in Unity after the player has died or at any time during the game according to user input. Most of the games these days are doing it and people can see the screenshots in the game and get the option to share the screenshot to social media like Facebook, Twitter and more. Today we will discuss the most simple way to take screenshots of the game in Unity and display it on the screen.

If you are interested in sharing the screenshot to Social Media, here's part 2: Share Screenshot.

Here is how Hill Climb Racing uses screenshot.


Take screenshot of game using Unity

We will use the method CaptureScreenshot to take the screenshot. Taking screenshot using this way is very easy but the difficult part is making sure the screenshot has been saved before you display it. If you directly display the screenshot after the CaptureScreenshot method, it's highly likely that the screenshot hasn't been saved yet so you won't have a screenshot to display. The easiest way I've found is using yield. Let's take a look at the code below:

private IEnumerator takeScreenshot(){
        Application.CaptureScreenshot("screenshotmygame.png", 0);
        //So that the screenshot is taken
        yield return new WaitForEndOfFrame ();
        yield return new WaitForSecondsRealtime(1.5f);

StartCoroutine (takeScreenshot ()); 

In the code above we have created a method called takeScreenshot that takes a screenshot using the first line. The first parameter is the name as which the screenshot image will be saved and the second parameter is the factor by which to increase the resolution. I've noticed that keeping the resolution factor just 0 or 1 is find as most of the devices now are already high resolution and the greater the scale the longer it takes to save the screenshot. The screenshots taken at 0 or 1 are just fine for sharing to social media.
In the yield statements that follow the CaptureScreenshot, the first statement waits for the current frame to end before running the next statement. This is supposed to work and the screenshot should be saved by the time frame has ended but that's not always the case, hence the WaitForSecondsRealime Method. The parameter of this method defines for delay after which the following statements should be executed. I've set it to 1.5f, it should be fine for most devices and worked will all the devices I tested. 1.5 seconds should be ample time for the screenshot to save.
The StartCoroutine methods just starts an IEnumerator Method as a Coroutine, i.e the methods is executed in parallel.
Now that we have successfully saved our screenshot, let's take a look at how to get it and display it in the game display.

Display the screenshot

Displaying the screenshot  is also fairly easy. We just need to provide the path of the screenshot, read the file, load it into a texture and override the sprite of Image component. Let's take a look at the code below.
NOTE: Please note that using this approach there is an UI Image component already in the game that set to unactive. It need to be set active before overriding its sprite. In the code below it's finalScreenShot.

public void GetPhoto()
        string url = Application.persistentDataPath + "/"+ "screenshotmygame.png";
        var bytes = File.ReadAllBytes(url);
        Texture2D texture = new Texture2D (2, 2);
        bool imageLoadSuccess = texture.LoadImage(bytes);
        while (!imageLoadSuccess) {
            print ("image load failed");
            bytes = File.ReadAllBytes(url);
            imageLoadSuccess = texture.LoadImage (bytes);
        print ("Image load success: " + imageLoadSuccess);
        finalScreenShot.GetComponent<Image> ().overrideSprite = Sprite.Create (texture, new Rect(0, 0, texture.width, texture.height), new Vector2(0f, 0f), 100f);

We have created a method call GetPhoto() that can be called for displaying the screenshot. the first method is just creating a url for the screenshot to be accessed. We are concatenating the path for game's file with the image name that we created in the first step. Then we real the image file byte by byte. Then we are loading the bytes in a texture. If the loading is failed we try it until it's successful and finally when the image is loaded successfully we just create a sprite from the texture and set it as the sprite of our UI image component. That's it! We have successfully captured the screenshot and then displayed it in our game. Try it out and if you have any questions feel free to comment below. Happy coding! :)
In the next part we will discuss how to share this screenshot to social media.


Responsive Column using Bootstrap Grid system and Multiple Column types.

Milan Malla
Responsiveness is a must quality for any website these days. And all the beginner web developers know that what a chaotic process it is to obtain a desired result.
Bootstrap has been the savior for a long time for developers like us. The most important aspect of Bootstrap is its 12-column mobile first grid system. This is what you use to create a responsive layout using grids.

For better understanding of 12-column mobile first grid system have look at below table from the official Bootstrap website.

Using bootstrap, you can specify different number of column grids based on different screen sizes.

In this tutorial, you will learn to make columns responsive using more than just one column class prefixes to achieve different number of column grids on different screen sizes.

First of all, you need to download the bootstrap from given link:

Now if we want 4 columns for devices with medium screen size, we would use .col-md-4 and it would give us exactly what we asked for:

<div class="row">
             <div class="col-md-4">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-md-4">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-md-4">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-md-4">
                 <img src="images/guy.jpg" alt="box">


Works well in devices having medium screen size, but in large devices the columns would look big and in small devices too small.

What most of the beginners don't know is that we can integrate more than one column types to    achieve optimized solution.

Lets say we want 4 columns for large devices, 3 columns for medium devices, 2 columns for small devices (tabloids) and 1 column for mobile devices.

What we do is write this simple piece of code:

<div class="row">
             <div class="col-lg-3 col-md-4 col-sm-6">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-lg-3 col-md-4 col-sm-6">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-lg-3 col-md-4 col-sm-6">
                 <img src="images/guy.jpg" alt="box">
             <div class="col-lg-3 col-md-4 col-sm-6">
                 <img src="images/guy.jpg" alt="box">

With above piece of code we get what we desired in best possible way. What we have done is defined class prefixes for different screen sizes. In the code above, class prefix col-lg-3 assigns 3 of the 12 available grids to one column, meaning there will be 4 columns in large devices, similarly col-md-4 means 3 columns in devices with medium screen size as 4 * 3 equals 12 and col-sm-6 means 2 columns will be displayed in devices with small screen size and 6*2 equals 12. Pretty neat right?
So, that is all for this tutorial. We will learn more about Bootstrap, columns, layouts and more designing techniques in upcoming tutorial. If you have any problems or comments feel free to comment below. Happy Coding.


How to get full sized Image from Camera Android

Vishal Shrestha
Getting Image from Camera in Android is pretty simple, however it gets pretty tricky if you need to get full quality image from the camera. When you launch intent with action image capture and only use the data.getExtras().get("data"), what you basically get is just the thumbnail. For getting the high quality full size photo, you need to save the high quality photo in the phone storage or external storage and then get that photo using Uri. Without saving the photo, you cannot get a high quality photo from the camera. Luckily it's not that complex also, here are the steps involved in getting full sized picture from the camera in Android.


Get full sized image from camera in Android.

  1.  Create FileProvider: Most important thing to get a full sized image is to use a file provide. It is using file provider that you access the file that has been stored after been taken from the camera. To create fileProvider, write the following code in Manifest.xml:
  2. Create file path in xml: Now you need to create a file in xml that defines path where images will be stored. Create a new folder in res called xml and create a new file called file_paths.xml inside it and add the following code:

    <?xml version="1.0" encoding="utf-8"?>
        <external-path name="my_images" fullpath="storage/emulated/0/Pictures/" />
  3. Get file write permission: As I've already mentioned you'll need to save the high quality full resolution first, before you can use it. So you need to the file write permissions so that you can save the photo first. Define this in manifest first - 

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

    Now if you plan on using the app on devices greater then Marshmallow, which you probably should right now you will need  to ask for permission on runtime. Here's how you do it-

    requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);

    Now you can handle whether the user has selected give permission of not in onRequestPermissionsResult. Once you have the permission, create an Image_capture intent.
  4. Create Image capture intent: Now create a new intent with image capture action. Here's the code:
    Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  5. Create a file and get file path and Start the action image capture intent:Now you need to create file, this is the file in which the image will be saved. Once the file is created get the path of the file.

       File photoFile = null;
                try {
                    photoFile = createImageFile();
                } catch (IOException ex) {
                    // Error occurred while creating the File
                    Log.d("mylog", "Exception while creating file: " + ex.toString());
                // Continue only if the File was successfully created
                if (photoFile != null) {
                    Log.d("mylog", "Photofile not null");
                    Uri photoURI = FileProvider.getUriForFile(ActivityMain.this,
                    takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);
                    startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE);

    Here's the code for createImageFile()

    private File createImageFile() throws IOException {
            // Create an image file name
            String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
            String imageFileName = "JPEG_" + timeStamp + "_";
            File storageDir = getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
            File image = File.createTempFile(
                    imageFileName,  /* prefix */
                    ".jpg",         /* suffix */
                    storageDir      /* directory */

            // Save a file: path for use with ACTION_VIEW intents
            mCurrentPhotoPath = image.getAbsolutePath();
            Log.d("mylog", "Path: " + mCurrentPhotoPath);
            return image;
  6. Handle the intent response in onActivityResult(){}. Now you've got everything in place, now just get the full size image from the storage and display in an imageView or upload it or do anything you want with it. Here how you get the full size image from storage after it's been captured.
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
            } else if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK) {
                Uri uri = data.getData();
                try {
                    Bitmap bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), uri);
                } catch (IOException e) {
You are done, now you should be able to successfully get full sized image from your phone's camera. If you have any problem, feel free to comment below. Happy coding!

Coprights @ 2017 | The Code City by Vishal Shrestha Vishal Shrestha