Android NANOHttpd share images example

Android NANOHttpd

Share files between the device using local network.

* Pic images from phone gallery and share with local network.
*It will work only same wifi network
*share files have used GET method.

add gradle

dependencies {
  
    compile 'org.nanohttpd:nanohttpd:2.2.0'   
}

Activity source code  

package nanohttpd.test.com.postimage;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import com.esafirm.imagepicker.features.ImagePicker;

public class MainActivity extends AppCompatActivity {

    public  static int REQUEST_CODE_PICKER =103;
    NanoTest mService;
    Button btn;
    String imagePath ="";
    @Override    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
         btn = (Button)findViewById(R.id.button);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override            public void onClick(View view) {

                ImagePicker.create(MainActivity.this) // Activity or Fragment                        .start(REQUEST_CODE_PICKER);
            }
        });
    }

    @Override    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if (requestCode == REQUEST_CODE_PICKER && resultCode == RESULT_OK && data != null) {

          //  printImages(images);
            imagePath = ""+ImagePicker.getImages(data).get(0).getPath();
            if(mService != null) {
                mService.setImagePath(imagePath);
            }
            Log.e("MainActivity","imagePath :: " +ImagePicker.getImages(data).get(0).getPath());
            Intent mIntent = new Intent(this, NanoTest.class);
            bindService(mIntent, mConnection, Context.BIND_AUTO_CREATE);
            return;
        }
    }

    private ServiceConnection mConnection = new ServiceConnection () {
        @Override        public void onServiceConnected(ComponentName className, IBinder service) {
            NanoTest.NanoTestBinder binder = (NanoTest.NanoTestBinder) service;
            mService = binder.getService();
            if(mService != null) {
                mService.setImagePath(imagePath);
            }
            mService.initializeServices(true,imagePath);
        }
        @Override        public void onServiceDisconnected(ComponentName arg0) {
            mService = null;
        }
    };



}

NanoHttpUtils Class

package nanohttpd.test.com.postimage;

import android.app.Service;
import android.content.Intent;
import android.net.wifi.WifiManager;
import android.os.Binder;
import android.os.Environment;
import android.os.IBinder;
import android.util.Log;


import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import fi.iki.elonen.NanoHTTPD;
import fi.iki.elonen.NanoHTTPD.Method;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class NanoTest extends Service  implements Callback<String> {
   private static final String AUTH_TYPE            = "Basic ";
   private static final String TAG                = "[NANO]";
   private static final int BUFFER_SIZE               = 128;       // 128 bytes   private static final int RECEIVE_TIMEOUT         = 1000*30;        // 30 sec   private static final String BROADCAST_MESSAGE_HELLO = "Hello";
   private static final String BROADCAST_MESSAGE_REPLY = "HRU";
   public static final int PORT = 1507;
   private final IBinder mBinder                 = new NanoTestBinder();
   private static String[] ipAddresses             = null;
   private TestNanoHttpD server                  = null;
   private HashMap<String, ServerSyncService>
                              allSyncServices = null;
   private volatile DatagramSocket socket              = null;
   // Client specific   private static InetAddress lastKnownServerAddress  = null;          /*< Auto-detected server address */   private boolean bRunDetection                 = true;
   private static final int SLEEP_TIME             = 30*60*1000;  // 30 minutes   private static final int NONE_FOUND_SLEEP_TIME    = 1000*30;    // 30 sec   private static final String MIME_JSON = "application/json";
   String imagePath ="";

   @Override   public void onResponse(Call<String> call, Response<String> response) {

      Log.d("response","response ::: " +response);
   }

   @Override   public void onFailure(Call<String> call, Throwable t) {

   }

   public class NanoTestBinder extends Binder {
      public NanoTest getService() {
            return NanoTest.this;
        }
   }
   
   public static abstract class ServerSyncService {
      protected static final String OLDEST_TIMESTAMP = "2016-05-10T00:00:00.000Z";
      public abstract String processData(Method method, String json, String offset);
      public abstract String getListenUri();
      public static String getJsonStatus(String status) {
         if(status == null)
            status = "success";
         return "{\"data\":\""+status+"\"}";
      }

   };
   
   public static final String[] getCurrentIpAddresses() {
      return ipAddresses;
   }
   
   public static final InetAddress getLastKnownServerAddress() {
      return lastKnownServerAddress;
   }
    
   @Override   public void onCreate() {
      super.onCreate();
   }

   @Override   public IBinder onBind(Intent intent) {
      return mBinder;
   }
   
   @Override   public boolean onUnbind(Intent intent) {
      stopServer();
      stopServerDetection();
      return false;
   }
   
   public void initializeServices(boolean bServer,String imagePaths) {
      imagePath = imagePaths;
      getAllIpAddresses();
         restartServer();
   }
   
   private void stopServerDetection() {
      bRunDetection = false;
   }
   
   private void startServerDetection() {
      bRunDetection = true;
      Thread thread = new Thread(new Runnable() {
         @Override         public void run() {
            try {
               while(bRunDetection) {
                  findServer();
                  Thread.sleep(lastKnownServerAddress == null ? NONE_FOUND_SLEEP_TIME : SLEEP_TIME);
               }
            } catch(Exception e) {
               e.printStackTrace();
            }
            
         }
      });
      thread.start();
   }
   
   public void stopServer() {
      // Close Broadcast Server      if(socket != null)
         socket.close();
      socket = null;

      // Close API Server      if(server != null && server.isAlive())
         server.stop();
      server = null;
      
   }

   public void setImagePath(String imagePath) {
      this.imagePath = imagePath;
   }

   private void startBroadcastServer() {
      try {
         // Start Broadcast server         socket = new DatagramSocket(PORT, InetAddress.getByName("0.0.0.0"));
         socket.setBroadcast(true);
         Thread thread = new Thread(new Runnable() {
            @Override            public void run() {
               byte[] recvBuf = new byte[BUFFER_SIZE];
               while(socket != null) {
                  try {
                     DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length);
                     socket.receive(packet);
                     String message = new String(packet.getData()).trim();
                     Log.d(TAG, "Server Received:"+message+":"+packet.getAddress().getHostAddress()+":"+packet.getPort());
                     if(message.equalsIgnoreCase(BROADCAST_MESSAGE_HELLO)) {
                        byte[] sendData = BROADCAST_MESSAGE_REPLY.getBytes();
                        DatagramPacket sendPacket = new DatagramPacket(sendData,
                                                            sendData.length,
                                                            packet.getAddress(),
                                                            packet.getPort());
                        socket.send(sendPacket);
                     }
                  } catch(SocketException e) {
                     e.printStackTrace();
                     socket = null;
                  } catch(Exception e) {
                     e.printStackTrace();
                  }
               }
            }
         });
         thread.start();
      } catch(Exception e) {
         e.printStackTrace();
      }
   }

   /**    * Tries finding a server.    *    * Requires to be run on a different thread.    *     * @return Returns lastKnownServerAddress (can be null)    */   public static InetAddress findServer() {
      DatagramSocket client = null;
      try {
         client = new DatagramSocket();
         byte[] helloMessage = BROADCAST_MESSAGE_HELLO.getBytes();
         client.setBroadcast(true);

         // Try Broadcast IP         DatagramPacket sendPacket = new DatagramPacket(helloMessage,
                                             helloMessage.length,
                                             InetAddress.getByName("255.255.255.255"),
                                             PORT);
         client.send(sendPacket);

         // Try Receiving response         byte[] recvBuf = new byte[BUFFER_SIZE];
         Log.d(TAG, "Starting receive...");
         DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length);
         client.setSoTimeout(RECEIVE_TIMEOUT);
         client.receive(packet);
         String message = new String(packet.getData()).trim();
         Log.d(TAG, "Client Received:"+message);
         if(message.equalsIgnoreCase(BROADCAST_MESSAGE_REPLY)) {
            lastKnownServerAddress = packet.getAddress();
            Log.d(TAG, "Found Server:"+lastKnownServerAddress.getHostAddress()+":"+lastKnownServerAddress.getHostName());
         }
      } catch(SocketTimeoutException e) {
         Log.d(TAG, "Timedout...");
      } catch(Exception e) {
         e.printStackTrace();
      } finally {
         if(client != null)
            client.close();
      }
      return lastKnownServerAddress;
   }

   private void startServer() throws IOException {
      // Start API Server      server = new TestNanoHttpD();
      server.start();
      
      startBroadcastServer();
   }

   private void restartServer() {
      try {
         stopServer();

         startServer();
      } catch(IOException e) {
         e.printStackTrace();
      }
   }
   
   private void getAllIpAddresses() {
      ArrayList<String> addresses = new ArrayList<String>();
       try {
           for(Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
               NetworkInterface intf = en.nextElement();
               for(Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
                   InetAddress inetAddress = enumIpAddr.nextElement();
                   if(!inetAddress.isLoopbackAddress()) {
                      Log.e(TAG, "Adding IP Address:"+inetAddress.getHostAddress().toString());
                       addresses.add(inetAddress.getHostAddress().toString());
                   }
                }
            }
        } catch (SocketException ex) {
            ex.printStackTrace();
        }
        ipAddresses = addresses.toArray(new String[0]);
   }

   private class TestNanoHttpD extends NanoHTTPD {
      
      public TestNanoHttpD() throws IOException {
         super(PORT);
      }

      private String mapToString(Map<String, String> params) {
         final StringBuilder buf = new StringBuilder();
         for(Map.Entry<String, String> entry : params.entrySet()) {
            buf.append(entry.getKey() + ":" + entry.getValue() + "\n");
         }
         return buf.toString();
      }

      @Override      public Response serve(String uri, Method method, Map<String, String> headers, Map<String, String> params, Map<String, String> files) {
         FileInputStream fis = null;
         try {
            fis = new FileInputStream(imagePath);
         } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
         }

         return newFixedLengthResponse(Response.Status.OK, "image/jpeg", fis,50000000);
      }


   }


}

Android Load images from Flikr

Fetch the images from Flikr and cache the images without third party library

1. List of images

2. On click flip the image and get image information

Activity Code

Source Code

Android HD Video Player

HD Video Player application for android . it will support all major Video formats

Android Studio - “Unmappable character for encoding UTF-8”

 Adding the following to build.gradle solves the problem :

 

android {
  
    compileOptions.encoding = 'ISO-8859-1'  

 }

 

 

java.lang.NoClassDefFoundError: com.google.android.gms.R$string

java.lang.NoClassDefFoundError: com.google.android.gms.R$string

Include in your build.gradle dependencies this:

compile 'com.android.support:multidex:1.0.0'

 your Manifest add MultiDexApplication class

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.android.multidex.myapplication">
    <application
        ...
        android:name="android.support.multidex.MultiDexApplication">
        ...
    </application>
</manifest>

If you already have your application class just extend it with MultiDexApplication class

How to get Particular application used Facebook Friends

This post about how to get particular application used friends.

* You can get friend list who is using particular application.

Source Code Here

FacebookSdk.sdkInitialize(this);

GraphRequest request=   new GraphRequest(
        AccessToken.getCurrentAccessToken(),
        "/me/friends",
        null,
        HttpMethod.GET,
        new GraphRequest.Callback() {
            public void onCompleted(GraphResponse response) {
        

            }
        }
);

request.executeAsync();
Output
{  
   "data":[  
      {  
         "name":"Veena Potter",
         "id":"*******************"
      },
      {  
         "name":"VijayaKumar Muniappan",
         "id":"*********"
      },
      {  
         "name":"Mohammed Siddiq",
         "id":"1234324*********"
      }
   ],
   "paging":{  
      "next":"https:\/\/graph.facebook.com\/v2.5\/198639363810546\/friends?format=json&access_token=CAAOKcZCOlbVwBADkN0puCASZAdSJNPsHOqmUAZAPZB70OkftsRcIUSYZA9zKkWDFJbLvOZCwoFaTnWd9U6aa60ulmJ3aPiGKHZAtBxZBAQSNoojGZBVcDGDkd742jVkYIQkMlZAfaw7eNuwsN4dgHZBw29YnuxR5wHfeEcJMdFEgLZBJ7aSHCKYyjvDRsB0K03KtKiRZCv9RhNlFc9wZDZD&limit=25&offset=25&__after_id=enc_AdCJnOgPxZCJgh6xM5sZA3BoTs7q9POI3iIWOcsorUgCTJcHVg1jRUSO8vcoIkCvYkG7hSVf2hCZCi2U0rZAA1ZB6pfkZA"
   },
   "summary":{  
      "total_count":5
   }
},
error:null
}