インターネットからデータを取得するandroid

Question

インターネットからデータを取得するAndroidアプリケーションを構築したいと考えています。たとえば、Yahoo Financeからのデータを使用する非常にシンプルな株式アプリケーションを作成したいと考えています。私はちょうど学習プロセスのためにこれをしたいと思う。だから誰かが私に説明のあるコードの例を教えたり、この分野で指定されている書籍をいくつか教えてください。ありがとう！

Answer 1

はこれを試してみてください：これはNTPからの時間がかかる場合の例です。

SntpClient client = new SntpClient(); 
String dateFromNtpServer = ""; 
if (client.requestTime("0.us.pool.ntp.org", 30000)) { 
       time = client.getNtpTime(); 
       newTime = time; 
       Log.d("shetty", newTime + "....newTime"); 

       Calendar calendar = Calendar.getInstance(); 
       try { 

        calendar.setTimeInMillis(time); 



        calendar.getTime(); 


        GMTtoEST gmttoest = new GMTtoEST(); 
        dateFromNtpServer = gmttoest 
          .ReturnMeEst(calendar.getTime()); 

        dateFromNtpServer = dateFromNtpServer + " EST"; 


       } catch (Exception e) { 
        // TODO: handle exception 
        dateFromNtpServer = "No Response from NTP"; 
       } 

      } 

2）GMTToEst.java

import java.text.DateFormat; 
import java.text.SimpleDateFormat; 
import java.util.Date; 
import java.util.TimeZone; 

public class GMTtoEST { 
    public static void main(String args[]) { 

     Date date = new Date(); 
     DateFormat estFormat = new SimpleDateFormat(); 
     DateFormat gmtFormat = new SimpleDateFormat(); 
     TimeZone gmtTime = TimeZone.getTimeZone("GMT"); 
     TimeZone estTime = TimeZone.getTimeZone("EST"); 
     estFormat.setTimeZone(gmtTime); 
     gmtFormat.setTimeZone(estTime); 
     System.out.println("GMT Time: " + estFormat.format(date)); 
     System.out.println("EST Time: " + gmtFormat.format(date)); 

    } 

    public String ReturnMeEst(Date GmtTime) { 
     // Date date = new Date(); 

     DateFormat estFormat = new SimpleDateFormat(); 
     DateFormat gmtFormat = new SimpleDateFormat(); 

     TimeZone gmtTime = TimeZone.getTimeZone("GMT"); 
     TimeZone estTime = TimeZone.getTimeZone("EST"); 

     estFormat.setTimeZone(gmtTime); 

     String timeInGmt = ""; 
     gmtFormat.setTimeZone(estTime); 

     // System.out.println("GMT Time: " + estFormat.format(date)); 
     System.out.println("EST Time: " + gmtFormat.format(GmtTime)); 

     timeInGmt = gmtFormat.format(GmtTime); 

     return timeInGmt; 
    } 

} 

3）SntpClient.java

import java.net.DatagramPacket; 
import java.net.DatagramSocket; 
import java.net.InetAddress; 

import android.os.SystemClock; 
import android.util.Config; 
import android.util.Log; 

/** 
* {@hide} 
* 
* Simple SNTP client class for retrieving network time. 
* 
* Sample usage: 
* <pre>SntpClient client = new SntpClient(); 
* if (client.requestTime("time.foo.com")) { 
*  long now = client.getNtpTime() + SystemClock.elapsedRealtime() - client.getNtpTimeReference(); 
* } 
* </pre> 
*/ 
public class SntpClient 
{ 
    private static final String TAG = "SntpClient"; 

    private static final int REFERENCE_TIME_OFFSET = 16; 
    private static final int ORIGINATE_TIME_OFFSET = 24; 
    private static final int RECEIVE_TIME_OFFSET = 32; 
    private static final int TRANSMIT_TIME_OFFSET = 40; 
    private static final int NTP_PACKET_SIZE = 48; 

    private static final int NTP_PORT = 123; 
    private static final int NTP_MODE_CLIENT = 3; 
    private static final int NTP_VERSION = 3; 

    // Number of seconds between Jan 1, 1900 and Jan 1, 1970 
    // 70 years plus 17 leap days 
    private static final long OFFSET_1900_TO_1970 = ((365L * 70L) + 17L) * 24L * 60L * 60L; 

    // system time computed from NTP server response 
    private long mNtpTime; 

    // value of SystemClock.elapsedRealtime() corresponding to mNtpTime 
    private long mNtpTimeReference; 

    // round trip time in milliseconds 
    private long mRoundTripTime; 

    /** 
    * Sends an SNTP request to the given host and processes the response. 
    * 
    * @param host host name of the server. 
    * @param timeout network timeout in milliseconds. 
    * @return true if the transaction was successful. 
    */ 
    public boolean requestTime(String host, int timeout) { 
     try { 
      DatagramSocket socket = new DatagramSocket(); 
      socket.setSoTimeout(timeout); 
      InetAddress address = InetAddress.getByName(host); 
      byte[] buffer = new byte[NTP_PACKET_SIZE]; 
      DatagramPacket request = new DatagramPacket(buffer, buffer.length, address, NTP_PORT); 

      // set mode = 3 (client) and version = 3 
      // mode is in low 3 bits of first byte 
      // version is in bits 3-5 of first byte 
      buffer[0] = NTP_MODE_CLIENT | (NTP_VERSION << 3); 

      // get current time and write it to the request packet 
      long requestTime = System.currentTimeMillis(); 
      long requestTicks = SystemClock.elapsedRealtime(); 
      writeTimeStamp(buffer, TRANSMIT_TIME_OFFSET, requestTime); 

      socket.send(request); 

      // read the response 
      DatagramPacket response = new DatagramPacket(buffer, buffer.length); 
      socket.receive(response); 
      long responseTicks = SystemClock.elapsedRealtime(); 
      long responseTime = requestTime + (responseTicks - requestTicks); 
      socket.close(); 

      // extract the results 
      long originateTime = readTimeStamp(buffer, ORIGINATE_TIME_OFFSET); 
      long receiveTime = readTimeStamp(buffer, RECEIVE_TIME_OFFSET); 
      long transmitTime = readTimeStamp(buffer, TRANSMIT_TIME_OFFSET); 
      long roundTripTime = responseTicks - requestTicks - (transmitTime - receiveTime); 
      // receiveTime = originateTime + transit + skew 
      // responseTime = transmitTime + transit - skew 
      // clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime))/2 
      //    = ((originateTime + transit + skew - originateTime) + 
      //    (transmitTime - (transmitTime + transit - skew)))/2 
      //    = ((transit + skew) + (transmitTime - transmitTime - transit + skew))/2 
      //    = (transit + skew - transit + skew)/2 
      //    = (2 * skew)/2 = skew 
      long clockOffset = ((receiveTime - originateTime) + (transmitTime - responseTime))/2; 
      // if (Config.LOGD) Log.d(TAG, "round trip: " + roundTripTime + " ms"); 
      // if (Config.LOGD) Log.d(TAG, "clock offset: " + clockOffset + " ms"); 

      // save our results - use the times on this side of the network latency 
      // (response rather than request time) 
      mNtpTime = responseTime + clockOffset; 
      mNtpTimeReference = responseTicks; 
      mRoundTripTime = roundTripTime; 
     } catch (Exception e) { 
      if (Config.LOGD) 
      Log.d(TAG, "request time failed: " + e); 
      return false; 
     } 

     return true; 
    } 

    /** 
    * Returns the time computed from the NTP transaction. 
    * 
    * @return time value computed from NTP server response. 
    */ 
    public long getNtpTime() { 
     return mNtpTime; 
    } 

    /** 
    * Returns the reference clock value (value of SystemClock.elapsedRealtime()) 
    * corresponding to the NTP time. 
    * 
    * @return reference clock corresponding to the NTP time. 
    */ 
    public long getNtpTimeReference() { 
     return mNtpTimeReference; 
    } 

    /** 
    * Returns the round trip time of the NTP transaction 
    * 
    * @return round trip time in milliseconds. 
    */ 
    public long getRoundTripTime() { 
     return mRoundTripTime; 
    } 

    /** 
    * Reads an unsigned 32 bit big endian number from the given offset in the buffer. 
    */ 
    private long read32(byte[] buffer, int offset) { 
     byte b0 = buffer[offset]; 
     byte b1 = buffer[offset+1]; 
     byte b2 = buffer[offset+2]; 
     byte b3 = buffer[offset+3]; 

     // convert signed bytes to unsigned values 
     int i0 = ((b0 & 0x80) == 0x80 ? (b0 & 0x7F) + 0x80 : b0); 
     int i1 = ((b1 & 0x80) == 0x80 ? (b1 & 0x7F) + 0x80 : b1); 
     int i2 = ((b2 & 0x80) == 0x80 ? (b2 & 0x7F) + 0x80 : b2); 
     int i3 = ((b3 & 0x80) == 0x80 ? (b3 & 0x7F) + 0x80 : b3); 

     return ((long)i0 << 24) + ((long)i1 << 16) + ((long)i2 << 8) + (long)i3; 
    } 

    /** 
    * Reads the NTP time stamp at the given offset in the buffer and returns 
    * it as a system time (milliseconds since January 1, 1970) 
    */  
    public long readTimeStamp(byte[] buffer, int offset) { 
     long seconds = read32(buffer, offset); 
     long fraction = read32(buffer, offset + 4); 
     return ((seconds - OFFSET_1900_TO_1970) * 1000) + ((fraction * 1000L)/0x100000000L);   
    } 

    /** 
    * Writes system time (milliseconds since January 1, 1970) as an NTP time stamp 
    * at the given offset in the buffer. 
    */  
    private void writeTimeStamp(byte[] buffer, int offset, long time) { 
     long seconds = time/1000L; 
     long milliseconds = time - seconds * 1000L; 
     seconds += OFFSET_1900_TO_1970; 

     // write seconds in big endian format 
     buffer[offset++] = (byte)(seconds >> 24); 
     buffer[offset++] = (byte)(seconds >> 16); 
     buffer[offset++] = (byte)(seconds >> 8); 
     buffer[offset++] = (byte)(seconds >> 0); 

     long fraction = milliseconds * 0x100000000L/1000L; 
     // write fraction in big endian format 
     buffer[offset++] = (byte)(fraction >> 24); 
     buffer[offset++] = (byte)(fraction >> 16); 
     buffer[offset++] = (byte)(fraction >> 8); 
     // low order bits should be random data 
     buffer[offset++] = (byte)(Math.random() * 255.0); 
    } 
} 

Answer 2

ヤフーには、ある種のAPIがあると思います。あなたは簡単なAPIの応答/要求の通信を処理する方法の良いスタートのために、Twitterアプリケーションを構築する方法（彼らは非常にフレンドリーなAPIを持っています）のいくつかの例を検索することができます。いくつかの例：

http://www.vogella.de/blog/2010/02/15/twitter-android/

http://codehenge.net/blog/2011/05/android-programming-tutorial-a-simple-twitter-feed-reader/