Birjesh Gupta – MaXEster Technologies | Technical Blog

How to make camera follow the player in Unity 3d?

Birjesh Gupta — Mon, 24 Feb 2020 08:07:37 +0000

In this article we will learn about. How do you make the camera follow the player in Unity 3d?

And, we’ll enable the camera to follow the player around the play field by writing a simple C# script.

Create a script for Camera.

click on Main Camera –> go to Inspector window –> click on Add components –>new Script –>Name the script(CameraController).

Go to inside the Project Window.

right-click–> create –> C# Script

Rename the file as CameraController

Now, paste the following code into your script.

using UnityEngine;
using System.Collections;

public class CameraController : MonoBehaviour {

    public GameObject player;        //Public variable to store a reference to the player game object


    private Vector3 offset;            //Private variable to store the offset distance between the player and camera

    // Use this for initialization
    void Start () 
    {
        //Calculate and store the offset value by getting the distance between the player's position and camera's position.
        offset = transform.position - player.transform.position;
    }

    // LateUpdate is called after Update each frame
    void LateUpdate () 
    {
        // Set the position of the camera's transform to be the same as the player's, but offset by the calculated offset distance.
        transform.position = player.transform.position + offset;
    }
}

If you were created script from Project window then drag and drop the script on Main Camera. It will add the script to main Camera.

Now, Drag and Drop the Player into Player field inside on CameraController script inside the Main Camera Inspector window.

Now, Run the project and you will get the camera follow the Player movement.

Hope this will be helpfull for you.

Thank You.

The post How to make camera follow the player in Unity 3d? appeared first on MaXEster Technologies | Technical Blog.

Method Reference In Java 8.

Birjesh Gupta — Fri, 03 Jan 2020 07:37:19 +0000

One of the most welcome changes in Java 8 was the introduction of Lambda Expression and Method Reference In java 8..

Method references in java are a special type of lambda expressions. because they’re often used to create simple lambda expressions by referencing existing methods.

It is compact and easy form of lambda expression. Each time when you are using lambda expression to just referring a method, you can replace your lambda expression with method reference.

So in this , we are explaining method reference in java concept in detail.

Types of method reference in java.

Method Reference to a static method.
Reference to a instance method.
Reference to a constructor.

1. Method Reference to a static method.

syntax :-

ContainingClass::staticMethodName

Example:-

In the below example, we have defined a functional interface and referring a static method to it’s functional method max().

interface Maxester{  
    void max();  
}  
public class MethodReference {  
    public static void welcome(){  
        System.out.println("Welcome, this is static method.");  
    }  
    public static void main(String[] args) {  
        // Referring static method  
        Maxester maxester = MethodReference::welcome;  
        // Calling interface method  
        maxester.max();  
    }  
}

Output:-

Welcome, this is static method.

2. Reference to a instance method.

syntax:-

 containingObject::instanceMethodName

Example:-

In the below example, we are referring non-static methods. we can refer methods by class object and also an anonymous object.

interface Maxester{  
    void max();  
}  
public class InstanceMethodReference {  
    public void welcome(){  
        System.out.println("Welcome, this is instance method.");  
    }  
    public static void main(String[] args) {  
        InstanceMethodReference methodReference = new InstanceMethodReference(); // Creating object  
        // Referring non-static method using reference  
            Maxester maxester = methodReference::welcome;  
        // Calling interface method  
            Maxester.max();  
            // Referring non-static method using anonymous object  
            Maxester maxester_first = new InstanceMethodReference()::welcome; // You can use anonymous object also  
            // Calling interface method  
            maxester_first.max();  
    }  
}

Output:-

Welcome, this is instance method.

3. Reference to a constructor.

syntax:-

 ClassName::new

Example:-

Interface Maxester{
      NewMaxester max(String value);
}
class NewMaxester{
      NewMaxester(String value){
         System.out.prinln(value);
     }
}
public class ConstrutorRefrenceMethod{
      public static void main(String[] args){
             Maxester maxester = NewMaxester::new;
             maxester.max("Welcome to maxester constructor");
        }
}

output:-

Welcome to maxester constructor.

External Link:-

You can also read much more about Method Reference from below link.

https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

So i hope, This will be helpful for you.

ThankYou.

The post Method Reference In Java 8. appeared first on MaXEster Technologies | Technical Blog.

Can we Overload the main() method in Java?

Birjesh Gupta — Thu, 19 Dec 2019 09:15:45 +0000

One of the common doubts among Java beginners while learning to overload and overriding is, whether it’s possible to overload main() in Java? Can you overload the main() method in Java? How will JVM find if you change the signature of the main method as part of the method overloading? etc.

So, the answer is Yes, We can overload the main() method in java but JVM only calls the original main method, it will never call our overloaded main method.

Overload Main() Method in Java.

This is just one way, you can create as many versions of main as you want, but you must make sure that the method signature of each main is different. You can change the method signature by changing the type of argument, number of arguments or order of arguments. Best practice to overload a method is by changing the number of arguments, or types of arguments. In Java, it’s not possible to overload the method by just changing return type.

Example:-

public class Maxester { 


// Overloaded main method 1  
    // Should be executed when character is passed 
    public static void main(char value) 
    { 
        System.out.println("Inside main(char value) method"); 
    } 
  
    // Overloaded main method 2 
   // Should be executed when int value is passed 
    public static void main(int value) 
    { 
        System.out.println("Inside main(int value) method"); 
    } 
    // Overloaded main method 3  
    // Should be executed when double value is passed 
    public static void main(Double[] value) 
    { 
        System.out.println("Inside main(Double[] value) method"); 
    } 
  
    // Original main() 
    public static void main(String[] args) 
    { 
        System.out.println("Inside original main(String[] args) method "); 
    } 
}

Output:-

Inside original main(Strings[] args) method.

As from the above example, it is clear that every time the original main method executes but not the overloaded methods because JVM only executes the original main method by default but not the overloaded one.

we can overload the main() method in java
But, to execute overloaded methods of main, we must call them from the original main method.

I hope this will be helpful to you.

Thank you.

The post Can we Overload the main() method in Java? appeared first on MaXEster Technologies | Technical Blog.

Setting Preference Activity In Android Q.

Birjesh Gupta — Wed, 18 Dec 2019 08:13:40 +0000

In this article, we are going to learn how we can use setting preference activity in Android. When we need certain settings in our app.

What is Setting Preference Activity?

A Setting Activity is an activity in the android studio which makes it easy to integrate the functionality and user interface in the application.

Use of Setting Preference Activity in Android.

Many times we need certain settings in our app, like setting default language, theme(light or dark), customizing notifications, etc.

In this tutorial, we will be creating a simple app with settings to change Image visibility.

But, For this, we will be using Shared Preferences.

In this article, we will be creating the first setting that is making the image visible or invisible by CheckBoxPreference.

Example For Setting Preference Activity in Android.

1:- Create a new android project.

File –> New –> Activity –> EmptyActivity –> name the project(SettingPrefrence) –>finish.

2:- In res/menu create a .xml file.

Right-click on the menu –> New –> menu resource file –> name the file(menu_item.xml) –>ok.

3:- In menu_item.xml copy the below code.

//menu_item.xml

4:- In MainActivity.java write the below code for creating and selection of menu items.

when we click on settings then the following methods will be called.

@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_item, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();

        if (id == R.id.action_settings) {
            // launch settings activity
            startActivity(new Intent(MainActivity.this, SettingsActivity.class));
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

5:- Now in activity_main.xml write below code for text view and image view.

6:- Now for Setting activity.

Right-click on the app –> new –> activity –> setting activity –>finish.

public class SettingsActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.settings_activity);
        getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.settings, new SettingsFragment())
                .commit();
        ActionBar actionBar = getSupportActionBar();
        if (actionBar != null) {
            actionBar.setDisplayHomeAsUpEnabled(true);
        }
    }

    public static class SettingsFragment extends PreferenceFragmentCompat {
        @Override
        public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
            setPreferencesFromResource(R.xml.root_preferences, rootKey);
        }
    }
}

And, you will get the above code in setting activity by default.

7:- Now, In rex/xml/root_preferences.xml copy the below code in your file for SwitchPreferenceCompat.

Attributes define:-

key = used for the id of the view.

defaultValue = true/false for making switch initially on/off. By default it is true.

summary = to provide a short description of the switch button.

title = to provide title/name of the switch button.

8:- In MainActivity file.

Now, implements your MainActivity file with SharedPreferences.OnSharedPreferenceChangeListener and copy the below code in your file.

public class MainActivity extends AppCompatActivity implements SharedPreferences.OnSharedPreferenceChangeListener {

    ImageView image;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        image = findViewById(R.id.image);
        ActionBar actionBar = this.getSupportActionBar();

        if (actionBar != null) {
            actionBar.setDisplayHomeAsUpEnabled(true);
        }
        setupSharedPreferences();
    }

    private void setImageVisible(boolean display_image) {
        if (display_image == true) {
            image.setVisibility(View.VISIBLE);
        } else {
            image.setVisibility(View.INVISIBLE);
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_item, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();

        if (id == R.id.action_settings) {
            // launch settings activity
            startActivity(new Intent(MainActivity.this, SettingsActivity.class));
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {


        if (key.equals("display_image")) {
            setImageVisible(sharedPreferences.getBoolean("display_image",true));
        }

    }
    private void setupSharedPreferences() {
        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        sharedPreferences.registerOnSharedPreferenceChangeListener(this);
    }

Here, the description of the above methods uses in the MainActivity file.

private void setupSharedPreferences() {
        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        sharedPreferences.registerOnSharedPreferenceChangeListener(this);
    }

Here, the Above method is used to set the switch button preference. It set true when on and false when off.

@Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {


        if (key.equals("display_image")) {
            setTextVisible(sharedPreferences.getBoolean("display_image",true));
        }

    }

Now, The above method is used to getting the preference data on switch button status changed.
It gets true when on and false when off.

and now,

private void setImageVisible(boolean display_image) {
        if (display_image) {
            image.setVisibility(View.VISIBLE);
        } else {
            image.setVisibility(View.INVISIBLE);
        }
    }

This method is used to set the visibility of the image. The image will visible when the switch button in on.

But,

The image will invisible when the switch button is off.

Now, you can run your project and you will get the following output.

Output:-

Now, when you turn on the switch button image will be visible.

And, I hope this article will helpful for you.

Thank you.

The post Setting Preference Activity In Android Q. appeared first on MaXEster Technologies | Technical Blog.

Lambda Expressions in Java.

Birjesh Gupta — Fri, 29 Nov 2019 11:24:00 +0000

Lambda expression in java is a new and important feature of Java which was included in Java SE 8.

And, Lambda expression in java also provides a clear and concise way to represent one method interface using an expression.

It is also very useful in the collection library. It helps to iterate, filter and extract data from the collection.

Functional Interface

An interface that has only one abstract method is called a functional interface.

But,

Lambda Expressions in Java also provides an annotation @FunctionalInterface, which is used to declare an interface as a functional interface.

Important Characteristics of a lambda expression.

1.Optional type declaration:

No need to declare the type of a parameter.

Also, The compiler can inference the same from the value of the parameter.

2. The optional parenthesis around parameter :

No need to declare a single parameter in parenthesis.

But, For multiple parameters, parentheses are required.

3. Optional curly braces

No need to use curly braces in the expression body if the body contains a single statement. Then, it is optional to return keyword

4. Optional return keyword

The compiler automatically returns the value if the body has a single expression to return the value.

Also, Curly braces are required to indicate that expression returns a value.

Why We Use Lambda Expression?

To provide the implementation of a Functional interface.
Less coding.

Syntax Of Lambda Expression

no parameter syntax

() -> {  
//Body of no parameter lambda  
}
//Lambda Expressions in Java.

one parameter syntax

(s1) -> {  
//Body of one parameter lambda  
}

//Lambda Expressions in Java.

two-parameter syntax

(s1,s2) -> {  
//Body of two parameter lambda  
}

//Lambda Expressions in Java.

Example:-

Without using Lambda Expression:

//Lambda Expressions in Java.

interface MyLambda{  
    public void lambda();  
}  
public class LambdaExample {  
    public static void main(String[] args) {  
        String name = "XYZ";  
  
        //without lambda, MyLambdaimplementation using anonymous class  
        MyLambda ml=new MyLambda(){  
            public void lambda(){System.out.println("Hello,  "+name);}  
        };  
        ml.lambda();  
    }  
}  

//Lambda Expressions in Java.

Output:

Hello, XYZ

Using Lambda Expression:

//Lambda Expressions in Java.

@FunctionalInterface  //It is optional 
interface MyLambda{  
    public String lambda(String name);  
}  
  
public class LambdaExample{  
    public static void main(String[] args) {  
      
        // Lambda expression with single parameter.  
        MyLambda my1=(name)->{  
            return "Hello, "+name;  
        };  
        System.out.println(my1.lambda("XYZ"));  
          
        // You can omit function parentheses    
        MyLambda my2= name ->{  
            return "Hello, "+name;  
        };  
        System.out.println(my2.lambda("ABC"));  
    }  
}

//Lambda Expressions in Java.

Output:

Hello, XYZ
Hello, ABC

You can also use no parameter and multiple parameters lambda expression as in the above example.

Then, you can see How Lambda Expression is very useful.

Also, I hope, this will be helpful for you.

You can also visit on below link for a brief Introduction about Lambda Expressions in Java.

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

ThankYou.

The post Lambda Expressions in Java. appeared first on MaXEster Technologies | Technical Blog.

Edit Text for OTP Using different boxes in Android.

Birjesh Gupta — Mon, 18 Nov 2019 05:11:48 +0000

Edit Text for OTP Using different boxes in Android.

The below solution takes into consideration:

Auto focusing to the next edit text on entering one digit of OTP in the focussed edit text.
Auto focusing to the previous edit text on deleting one digit of OTP in the focussed edit text.

We can achieve this by TextWatcher interaface and by make it more generic.

1. Create a new project “OtpWithBoxes“.

2. In res/drawable right click on drawble and create a new .xml file name edittext_curve_bg.xml for making edit text background curved and attractive and Copy below code in your .xml file.

3. Now, Copy the below code to your activity_main.xml file.

4.Now, Create a java class name GenericTextWatcher.java and implements with TextWatcher interface then copy the below code in your class.

public class GenericTextWatcher implements TextWatcher {
    private final EditText[] editText;
    private View view;
    public GenericTextWatcher(View view, EditText editText[])
    {
        this.editText = editText;
        this.view = view;
    }

    @Override
    public void afterTextChanged(Editable editable) {
            String text = editable.toString();
            switch (view.getId()) {

                case R.id.otp_edit_box1:
                    if (text.length() == 1)
                        editText[1].requestFocus();
                    break;
                case R.id.otp_edit_box2:

                    if (text.length() == 1)
                        editText[2].requestFocus();
                    else if (text.length() == 0)
                        editText[0].requestFocus();
                    break;
                case R.id.otp_edit_box3:
                    if (text.length() == 1)
                        editText[3].requestFocus();
                    else if (text.length() == 0)
                        editText[1].requestFocus();
                    break;
                case R.id.otp_edit_box4:
                    if (text.length() == 0)
                        editText[2].requestFocus();
                    break;
            }
    }

    @Override
    public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
    }

    @Override
    public void onTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) {
    }
}

In this class requestFocus() method is used to send the transfer focus to next field.

5. Then, In MainActivity copy the below code and add your on own feature on verify button.

public class MainActivity extends AppCompatActivity {

    EditText otp_textbox_one, otp_textbox_two, otp_textbox_three, otp_textbox_four;
    Button verify_otp;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        otp_textbox_one = findViewById(R.id.otp_edit_box1);
        otp_textbox_two = findViewById(R.id.otp_edit_box2);
        otp_textbox_three = findViewById(R.id.otp_edit_box3);
        otp_textbox_four = findViewById(R.id.otp_edit_box4);
        verify_otp = findViewById(R.id.verify_otp_btn);


        EditText[] edit = {otp_textbox_one, otp_textbox_two, otp_textbox_three, otp_textbox_four};

        otp_textbox_one.addTextChangedListener(new GenericTextWatcher(otp_textbox_one, edit));
        otp_textbox_two.addTextChangedListener(new GenericTextWatcher(otp_textbox_two, edit));
        otp_textbox_three.addTextChangedListener(new GenericTextWatcher(otp_textbox_three, edit));
        otp_textbox_four.addTextChangedListener(new GenericTextWatcher(otp_textbox_four, edit));


        verify_otp.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Toast.makeText(getApplicationContext(), "Login Successfull", Toast.LENGTH_SHORT).show();

            }
        });


    }

}

Now you can run your application and you will get desired output.

Hope this will Helpful for you.

The post Edit Text for OTP Using different boxes in Android. appeared first on MaXEster Technologies | Technical Blog.

Upload File/Image to the server using Volley in Android.

Birjesh Gupta — Fri, 04 Oct 2019 08:44:21 +0000

Upload file/image to the server using volley in Android is a very frequently used thing. In most of the apps, we need user avatar, i.e. user profile image.

In this article, we are going to see an example to Android upload a file/image to the server with a Multipart using volley.

What is a MultiPart Request?

https://source.android.com/reference/tradefed/com/android/tradefed/util/net/HttpMultipartPost

HttpMultipart requests are used to send heavy data or files like audio and video to the server.

Android Volley gives you a very faster and optimized environment to send heavy data or files to the server. Here I post an image file selected from the gallery.

Using Restful API

Here, I am going to use the below API URL to upload the file/image.

ROOT_URL =“http://seoforworld.com/api/v1/file-upload.php”

Please Check PHP code using this URL https://www.maxester.com/blog/2020/07/28/php-code-for-upload-image-to-server-using-volley-in-android/

Example of upload file/image to a server with the multipart request using volley.

1. Creating an Android project.

Open Android Studio and create a new project (I created UploadFile)

2. Add Dependency.

Add Volley to your project. You can quickly add it using Gradle. Extract Gradle Scripts and open build.gradle (Module: app)

 implementation 'com.android.volley:volley:1.1.1'
//Add this dependency to your project.

So your dependencies block will look like

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    implementation 'com.android.volley:volley:1.1.1'
    androidTestImplementation 'androidx.test:runner:1.2.0'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

3. Sync Project.

Now click on Sync Project With Gradle Icon from the top menu and it will automatically download and add volley library to your project.

4. Adding Permission in AndroidMainfest.xml file.

We also need the Internet and Read and Write Storage permission. So inside AndroidManifest.xml add these permissions.

your AndroidManifest.xml file will look like as below:-

5. User Interface

Now inside activity_main.xml and write the following XML code into your activity_main.xml.

6. VolleyMultipartRequest

Here, we need to perform a multipart request. But the problem is volley doesn’t support multipart requests directly. So that is why we need to create our Custom Volley Request.

Create a java class with VolleyMultipartRequest and write the below code in that file.

// VolleyMultipartRequest.java

public class VolleyMultipartRequest extends Request {


    private final String twoHyphens = "--";
    private final String lineEnd = "\r\n";
    private final String boundary = "apiclient-" + System.currentTimeMillis();

    private Response.Listener mListener;
    private Response.ErrorListener mErrorListener;
    private Map mHeaders;


    public VolleyMultipartRequest(int method, String url,
                                  Response.Listener listener,
                                  Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        this.mListener = listener;
        this.mErrorListener = errorListener;
    }

    @Override
    public Map getHeaders() throws AuthFailureError {
        return (mHeaders != null) ? mHeaders : super.getHeaders();
    }

    @Override
    public String getBodyContentType() {
        return "multipart/form-data;boundary=" + boundary;
    }

    @Override
    public byte[] getBody() throws AuthFailureError {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(bos);

        try {
            // populate text payload
            Map params = getParams();
            if (params != null && params.size() > 0) {
                textParse(dos, params, getParamsEncoding());
            }

            // populate data byte payload
            Map data = getByteData();
            if (data != null && data.size() > 0) {
                dataParse(dos, data);
            }

            // close multipart form data after text and file data
            dos.writeBytes(twoHyphens + boundary + twoHyphens + lineEnd);

            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Custom method handle data payload.
     *
     * @return Map data part label with data byte
     * @throws AuthFailureError
     */
    protected Map getByteData() throws AuthFailureError {
        return null;
    }

    @Override
    protected Response parseNetworkResponse(NetworkResponse response) {
        try {
            return Response.success(
                    response,
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (Exception e) {
            return Response.error(new ParseError(e));
        }
    }

    @Override
    protected void deliverResponse(NetworkResponse response) {
        mListener.onResponse(response);
    }

    @Override
    public void deliverError(VolleyError error) {
        mErrorListener.onErrorResponse(error);
    }

    /**
     * Parse string map into data output stream by key and value.
     *
     * @param dataOutputStream data output stream handle string parsing
     * @param params           string inputs collection
     * @param encoding         encode the inputs, default UTF-8
     * @throws IOException
     */
    private void textParse(DataOutputStream dataOutputStream, Map params, String encoding) throws IOException {
        try {
            for (Map.Entry entry : params.entrySet()) {
                buildTextPart(dataOutputStream, entry.getKey(), entry.getValue());
            }
        } catch (UnsupportedEncodingException uee) {
            throw new RuntimeException("Encoding not supported: " + encoding, uee);
        }
    }

    /**
     * Parse data into data output stream.
     *
     * @param dataOutputStream data output stream handle file attachment
     * @param data             loop through data
     * @throws IOException
     */
    private void dataParse(DataOutputStream dataOutputStream, Map data) throws IOException {
        for (Map.Entry entry : data.entrySet()) {
            buildDataPart(dataOutputStream, entry.getValue(), entry.getKey());
        }
    }

    /**
     * Write string data into header and data output stream.
     *
     * @param dataOutputStream data output stream handle string parsing
     * @param parameterName    name of input
     * @param parameterValue   value of input
     * @throws IOException
     */
    private void buildTextPart(DataOutputStream dataOutputStream, String parameterName, String parameterValue) throws IOException {
        dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
        dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" + parameterName + "\"" + lineEnd);
        dataOutputStream.writeBytes(lineEnd);
        dataOutputStream.writeBytes(parameterValue + lineEnd);
    }

    /**
     * Write data file into header and data output stream.
     *
     * @param dataOutputStream data output stream handle data parsing
     * @param dataFile         data byte as DataPart from collection
     * @param inputName        name of data input
     * @throws IOException
     */
    private void buildDataPart(DataOutputStream dataOutputStream, DataPart dataFile, String inputName) throws IOException {
        dataOutputStream.writeBytes(twoHyphens + boundary + lineEnd);
        dataOutputStream.writeBytes("Content-Disposition: form-data; name=\"" +
                inputName + "\"; filename=\"" + dataFile.getFileName() + "\"" + lineEnd);
        if (dataFile.getType() != null && !dataFile.getType().trim().isEmpty()) {
            dataOutputStream.writeBytes("Content-Type: " + dataFile.getType() + lineEnd);
        }
        dataOutputStream.writeBytes(lineEnd);

        ByteArrayInputStream fileInputStream = new ByteArrayInputStream(dataFile.getContent());
        int bytesAvailable = fileInputStream.available();

        int maxBufferSize = 1024 * 1024;
        int bufferSize = Math.min(bytesAvailable, maxBufferSize);
        byte[] buffer = new byte[bufferSize];

        int bytesRead = fileInputStream.read(buffer, 0, bufferSize);

        while (bytesRead > 0) {
            dataOutputStream.write(buffer, 0, bufferSize);
            bytesAvailable = fileInputStream.available();
            bufferSize = Math.min(bytesAvailable, maxBufferSize);
            bytesRead = fileInputStream.read(buffer, 0, bufferSize);
        }

        dataOutputStream.writeBytes(lineEnd);
    }

    class DataPart {
        private String fileName;
        private byte[] content;
        private String type;

        public DataPart() {
        }

        DataPart(String name, byte[] data) {
            fileName = name;
            content = data;
        }

        String getFileName() {
            return fileName;
        }

        byte[] getContent() {
            return content;
        }

        String getType() {
            return type;
        }

    }
}

7. Upload file/image to the server.

Now, the main thing to upload files/images to the server. We will do it inside the MainActivity.java file.

write the below code to your MainActivity.java file.

//MainActivity.java

public class MainActivity extends AppCompatActivity {


    private static final String ROOT_URL = "http://seoforworld.com/api/v1/file-upload.php";
    private static final int REQUEST_PERMISSIONS = 100;
    private static final int PICK_IMAGE_REQUEST =1 ;
    private Bitmap bitmap;
    private String filePath;
    ImageView imageView;
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //initializing views
        imageView =  findViewById(R.id.imageView);
        textView =  findViewById(R.id.textview);

        //adding click listener to button
        findViewById(R.id.buttonUploadImage).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if ((ContextCompat.checkSelfPermission(getApplicationContext(),
                        Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) && (ContextCompat.checkSelfPermission(getApplicationContext(),
                        Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)) {
                    if ((ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE)) && (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                            Manifest.permission.READ_EXTERNAL_STORAGE))) {

                    } else {
                        ActivityCompat.requestPermissions(MainActivity.this,
                                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE},
                                REQUEST_PERMISSIONS);
                    }
                } else {
                    Log.e("Else", "Else");
                    showFileChooser();
                }


            }
        });
    }

    private void showFileChooser() {
        Intent intent = new Intent();
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(Intent.createChooser(intent, "Select Picture"), PICK_IMAGE_REQUEST);
    }

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

        if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK && data != null && data.getData() != null) {
            Uri picUri = data.getData();
            filePath = getPath(picUri);
            if (filePath != null) {
                try {

                    textView.setText("File Selected");
                    Log.d("filePath", String.valueOf(filePath));
                    bitmap = MediaStore.Images.Media.getBitmap(getContentResolver(), picUri);
                    uploadBitmap(bitmap);
                    imageView.setImageBitmap(bitmap);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            else
            {
                Toast.makeText(
                       MainActivity.this,"no image selected",
                                 Toast.LENGTH_LONG).show();
            }
        }

    }
    public String getPath(Uri uri) {
        Cursor cursor = getContentResolver().query(uri, null, null, null, null);
        cursor.moveToFirst();
        String document_id = cursor.getString(0);
        document_id = document_id.substring(document_id.lastIndexOf(":") + 1);
        cursor.close();

        cursor = getContentResolver().query(
                android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                null, MediaStore.Images.Media._ID + " = ? ", new String[]{document_id}, null);
        cursor.moveToFirst();
        String path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
        cursor.close();

        return path;
    }


    public byte[] getFileDataFromDrawable(Bitmap bitmap) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 80, byteArrayOutputStream);
        return byteArrayOutputStream.toByteArray();
    }

    private void uploadBitmap(final Bitmap bitmap) {

        VolleyMultipartRequest volleyMultipartRequest = new VolleyMultipartRequest(Request.Method.POST, ROOT_URL,
                new Response.Listener() {
                    @Override
                    public void onResponse(NetworkResponse response) {
                        try {
                            JSONObject obj = new JSONObject(new String(response.data));
                            Toast.makeText(getApplicationContext(), obj.getString("message"), Toast.LENGTH_SHORT).show();
                        } catch (JSONException e) {
                            e.printStackTrace();
                        }
                    }
                },
                new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        Toast.makeText(getApplicationContext(), error.getMessage(), Toast.LENGTH_LONG).show();
                        Log.e("GotError",""+error.getMessage());
                    }
                }) {

          
            @Override
            protected Map getByteData() {
                Map params = new HashMap<>();
                long imagename = System.currentTimeMillis();
                params.put("image", new DataPart(imagename + ".png", getFileDataFromDrawable(bitmap)));
                return params;
            }
        };

        //adding the request to volley
        Volley.newRequestQueue(this).add(volleyMultipartRequest);
    }

}

8. Above code explanation.

The below code is used to take permission from the device for access gallery on Button click.

findViewById(R.id.buttonUploadImage).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if ((ContextCompat.checkSelfPermission(getApplicationContext(),
                        Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) && (ContextCompat.checkSelfPermission(getApplicationContext(),
                        Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED)) {
                    if ((ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                            Manifest.permission.WRITE_EXTERNAL_STORAGE)) && (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this,
                            Manifest.permission.READ_EXTERNAL_STORAGE))) {

                    } else {
                        ActivityCompat.requestPermissions(MainActivity.this,
                                new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE},
                                REQUEST_PERMISSIONS);
                    }
                } else {
                    Log.e("Else", "Else");
                    showFileChooser();
                }


            }
        });

In the MainActivity.java file, Function showFileChooser() is used to choose an image from the device gallery.

And, To complete the image choosing process we need to override the onActivityResult() method.

getPath() method is used to get the absolute path of the file/image.

And, uploadBitmap() method is used to upload file/image to the server.

9. Run the Project

On running the project you will get the following output.

a. Open the App

www.maxester.com

b. Click on the upload image button and give permission.

c. Image/File Uploaded

Download Source Code

Please Check PHP code using this URL https://www.maxester.com/blog/2020/07/28/php-code-for-upload-image-to-server-using-volley-in-android/

The post Upload File/Image to the server using Volley in Android. appeared first on MaXEster Technologies | Technical Blog.

JSON Parsing In Android

Birjesh Gupta — Fri, 20 Sep 2019 07:50:32 +0000

JSON (Javascript Object Notation) is very light-weight, structured, easy to parse and much human-readable. JSON is the best alternative to XML when your android app needs to interchange data with your server.

The JSON format was originally specified and developed by Douglas Crockford and is described in RFC 4627 license.
The JSON filename extension is .json.

Advantage of JSON over XML

1) JSON is faster and easier than XML for AJAX applications.
2) Unlike XML, it is shorter and quicker to read and write.
3) It uses array.

JSON notation contains these basic elements:

1. JSON Objects:

A JSON object contains key/value pairs like a map. The keys are strings and the values are the JSON types. Keys and values are separated by a comma. The curly braces ({ }) represents the JSON object.

https://developer.android.com/reference/org/json/JSONObject

{  
    "employee": {  
        "firstname": "birjesh",   
        "lastname": "gupta",   
        "email": "XXXXXX@mail.com" 
    }  
}

Here, “employee” is the JSON Object name.

2. JSON Arrays:

https://developer.android.com/reference/org/json/JSONArray

The square bracket ([ ]) represents the JSON array.

"Employee" :  
    [  
     {"id":"101","name":"Ravi","salary":"50000"},  
     {"id":"102","name":"Vimal","salary":"60000"}  
    ]

Here, “Employee” is the JSON Array Name.

Example of Android JSON Parsing:-

now, we are going to see an example of JSON parsing in Android:

1. Create a new project in Android Studio from

File –>New Project and fill out the required details.

2. As we are fetching the JSON, we need to add INTERNET permission in AndroidManifest.xml file. Open AndroidManifest.xml and add the following permission.


//AndroidManifest.xml

3. Create Assets folder inside your project like below.

Right-click on the app
app –>new–>folder–>Assets folder–>Finish
Assets Folder Created.

4. Create a local JSON file in the Assets folder named sample.json like below.

Now Right-click on assets folder
assets folder–>new–>file–>filename.json–>ok
New JSON File Created.
write the below code in your JSON file

//JSON Example:
//sample.json
{"employee":[{
  "firstname": "birjesh",
  "lastname" : "gupta",
  "email": "XXXXXX@gmail.com",
  "gender": "male",
  "phone": "89XXXXXX98"
},
  {
    "firstname": "suresh",
    "lastname" : "singh",
    "email": "XXXXXX@gmail.com",
    "gender": "male",
    "phone": "87XXXXXX87"
  },
  {
    "firstname": "manish",
    "lastname" : "sharma",
    "email": "XXXXXX@gmail.com",
    "gender": "male",
    "phone": "96XXXXXX69"
  },
  {
    "firstname": "gourav",
    "lastname" : "ganguly",
    "email": "XXXXXX@gmail.com",
    "gender": "male",
    "phone": "90XXXXXX09"
  },
  {
    "firstname": "mohan",
    "lastname" : "batra",
    "email": "XXXXXX@gmail.com",
    "gender": "male",
    "phone": "87XXXXXX87"
  }
]
}

5. Open the layout file of the main activity (activity_main.xml) and add a ListView element like below.

//activity_main.xml

6. Create another layout file named list_view_item.xml with the following content. This will be used to render a single list item view.

//list_view_item.xml

7. Create a java class named Constants.java and write below code to use get the value from JSON file and set to TextView.

//Constants.java

public class Constants {

    public static final String FIRST_NAME = "firstname";
    public static final String LAST_NAME = "lastname";
    public static final String EMAIL = "email";
    public static final String GENDER = "gender";
    public static final String PHONE = "phone";
    private HashMap relateds;

    //getter method to get the json data
    public HashMap getRelateds() {
        return relateds;
    }

    //setter method to set json data on textview
    public void setRelateds(HashMap relateds) {
        this.relateds = relateds;
    }
}

8. Now, Open the MainActivity.java class and create a public String readJsonFromAssets() method to open and use the local JSON file as shown below:-

//readJsonFromAssets()

//Read and open the .json file
public String readJsonFromAssets()
    {
        String json = null;
        try {
            InputStream is = getAssets().open("sample.json");
            int size = is.available();
            byte[] buffer =new byte[size];
            is.read(buffer);
            is.close();
            json = new String(buffer,"UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return json;
    }

as we opened JSON file now in onCreate() method
loadJson() is called to get the JSON from the file. Once the JSON is fetched, it is parsed and each contact is added to an array list. Write below code in your MainActivity.java class.

But,

Also, note that I have used getJSONArray() or getJSONObject() method depending on the type of node.

//MainActivity.java

public class MainActivity extends AppCompatActivity {

    ArrayList dataModel = new ArrayList<>();
    ListView listview;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        listview = findViewById(R.id.list_view);
        loadJson();
    }

    //Load json data from json file
    private void loadJson() {
        HashMap map = null;
        try {
            JSONObject object = new JSONObject(readJsonFromAssets());
            JSONArray jarray = object.getJSONArray("employee");

            for(int i=0; i();

                map.put(Constants.FIRST_NAME,obj.getString(Constants.FIRST_NAME));
                map.put(Constants.LAST_NAME,obj.getString(Constants.LAST_NAME));
                map.put(Constants.EMAIL,obj.getString(Constants.EMAIL));
                map.put(Constants.GENDER,obj.getString(Constants.GENDER));
                map.put(Constants.PHONE,obj.getString(Constants.PHONE));

                //Add json data to setter method of Constants class
                constant.setRelateds(map);
               
                //Add object to Arraylist
                dataModel.add(constant);
            }
            CustomViewAdapter customAdaptor = new CustomViewAdapter(this, dataModel);

            listview.setAdapter(customAdaptor);

        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

   //Read and open .json file
    public String readJsonFromAssets()
    {
        String json = null;
        try {
            InputStream is = getAssets().open("sample.json");
            int size = is.available();
            byte[] buffer =new byte[size];
            is.read(buffer);
            is.close();
            json = new String(buffer,"UTF-8");
        } catch (IOException e) {
            e.printStackTrace();
        }
        return json;
    }
}

9. Create a CustomViewAdapter.java class which extends BaseAdapter.class and implements its methods to set JSON string values into your TextView like below.

Write below code into you CustomView class.

//CustomViewAdapter extends BaseAdapter


public class CustomViewAdapter extends BaseAdapter {

    Context context;
    ArrayList datamodel;
    public CustomViewAdapter(Context context, ArrayList dataModel) {
        this.context = context;
        this.datamodel = dataModel;
    }

    @Override
    public int getCount() {
        return datamodel.size();
    }

    @Override
    public Object getItem(int i) {
        return null;
    }

    @Override
    public long getItemId(int i) {
        return 0;
    }

    @Override
    public View getView(int position, View view, ViewGroup parent) {

        TextView name,email,gender,phone;

        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View itemview = inflater.inflate(R.layout.list_view_item, parent, false);

        name = itemview.findViewById(R.id.person_name);
        email = itemview.findViewById(R.id.person_email);
        gender = itemview.findViewById(R.id.person_gender);
        phone = itemview.findViewById(R.id.person_phone);

        name.setText(datamodel.get(position).getRelateds().get(Constants.FIRST_NAME)
                +" "+datamodel.get(position).getRelateds().get(Constants.LAST_NAME));

        email.setText(datamodel.get(position).getRelateds().get(Constants.EMAIL              ));
        gender.setText(datamodel.get(position).getRelateds().get(Constants.GENDER));
        phone.setText(datamodel.get(position).getRelateds().get(Constants.PHONE));

        return itemview;
    }
}

LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View itemview = inflater.inflate(R.layout.list_view_item, parent, false);

LayoutInflater is used to inflate the list_view_item.xml file.

        name.setText(datamodel.get(position).getRelateds().get(Constants.FIRST_NAME)
                +" "+datamodel.get(position).getRelateds().get(Constants.LAST_NAME));

In the above code, simply I concat the firstname and lastname using (+) operator.

If you run the project, you can see JSON data populated into list view as shown in the below image.

maxester.com

Project Structure Must be like below:-

Download Zip file here

The post JSON Parsing In Android appeared first on MaXEster Technologies | Technical Blog.