los mapas de Google, cellid a la ubicación

Question

De acuerdo con esta muestra:

http://www.codeproject.com/KB/mobile/DeepCast.aspx

Es posible solicitar una coordenada GPS (longitud & latitud) incluyendo gama al enviar información cellid (MCC, MNC, towerid, etc)

¿Alguien me puede decir el parámetro real para solicitar/publicar en esta dirección?

http://www.google.com/glm/mmap

Podría ser algo como esto

http://www.google.com/glm/mmap?mcc=xxx&mnc=xxx&towerid=xxx 

y me gustaría saber cuál es la respuesta que se pueden conseguir.

He observado el sitio web de OpenCellid y proporcionan una buena API para empezar, pero también quiero saberlo en el mapa de Google (ya que tienen más bases de datos completadas).

OpenCellID API

Answer 1

Aquí es ejemplo para el trabajo con

#!/usr/bin/python 

country = 'fr' 
#device = 'Sony_Ericsson-K750' 
device = "Nokia N95 8Gb" 
user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' 
mmap_url = 'http://www.google.com/glm/mmap' 
geo_url = 'http://maps.google.com/maps/geo' 

from struct import pack, unpack 
from httplib import HTTP 
import urllib2 

def fetch_latlong_http(query): 
    http = HTTP('www.google.com', 80) 
    http.putrequest('POST', '/glm/mmap') 
    http.putheader('Content-Type', 'application/binary') 
    http.putheader('Content-Length', str(len(query))) 
    http.endheaders() 
    http.send(query) 
    code, msg, headers = http.getreply() 
    result = http.file.read() 
    return result 

def fetch_latlong_urllib(query): 
    headers = { 'User-Agent' : user_agent } 
    req = urllib2.Request(mmap_url, query, headers) 
    resp = urllib2.urlopen(req) 
    response = resp.read() 
    return response 

fetch_latlong = fetch_latlong_http 

def get_location_by_cell(cid, lac, mnc=0, mcc=0, country='fr'): 
    b_string = pack('>hqh2sh13sh5sh3sBiiihiiiiii', 
        21, 0, 
        len(country), country, 
        len(device), device, 
        len('1.3.1'), "1.3.1", 
        len('Web'), "Web", 
        27, 0, 0, 
        3, 0, cid, lac, 
        0, 0, 0, 0) 

    bytes = fetch_latlong(b_string) 
    (a, b,errorCode, latitude, longitude, c, d, e) = unpack(">hBiiiiih",bytes) 
    latitude = latitude/1000000.0 
    longitude = longitude/1000000.0 

    return latitude, longitude 

def get_location_by_geo(latitude, longitude): 
    url = '%s?q=%s,%s&output=json&oe=utf8' % (geo_url, str(latitude), str(longitude)) 
    return urllib2.urlopen(url).read() 

if __name__ == '__main__': 
    print get_location_by_cell(20465, 495, 3, 262) 
    print get_location_by_cell(20442, 6015) 
    print get_location_by_cell(1085, 24040) 
    print get_location_by_geo(40.714224, -73.961452) 
    print get_location_by_geo(13.749113, 100.565327) 

Answer 2

Como se ha señalado en otros temas también echa un vistazo https://labs.ericsson.com/apis/mobile-location/documentation/cell-id-look-up-api de una base de datos libre de células-ID para obtener coordenadas de cellid, MCC, MNC, y lac.

Answer 3

Puede utilizar la API de ubicación de Google que usa Firefox (Ejemplo: http://www.mozilla.com/en-US/firefox/geolocation/) que tiene la url www.google.com/loc/json/. De hecho esto se basa JSON servicio web y una mínima Ejemplo Perl tener este aspecto:

use LWP; 

my $ua = LWP::UserAgent->new; 
$ua->agent("TestApp/0.1 "); 
$ua->env_proxy(); 

my $req = HTTP::Request->new(POST => 'https://www.google.com/loc/json'); 

$req->content_type('application/jsonrequest'); 
$req->content('{"cell_towers": [{"location_area_code": "8721", "mobile_network_code": "01", "cell_id": "7703", "mobile_country_code": "262"}], "version": "1.1.0", "request_address": "true"}'); 

# Pass request to the user agent and get a response back 
my $res = $ua->request($req); 

# Check the outcome of the response 
if ($res->is_success) { 
    print $res->content; 
} else { 
    print $res->status_line, "\n"; 
    return undef; 
} 

Por favor, tenga en cuenta que Google no ha abierto oficialmente esta API para otros usos ...

Answer 4

Base en GeolocationAPI, aquí hay algunas partes de mi código:

import java.io.IOException; 
import java.io.StringWriter; 
import java.net.HttpURLConnection; 
import java.net.URL; 

//http://code.google.com/p/google-gson/ 
import com.google.gson.stream.JsonWriter; 

... 

/** 
* Requests latitude and longitude from Google. 
* 
* @param gsmParams 
*   {@link GsmParams} 
* @return an {@link HttpURLConnection} containing connection to Google 
*   lat-long data. 
* @throws IOException 
*/ 
public HttpURLConnection requestLatlongFromGoogle(GsmParams gsmParams) 
     throws IOException { 
    // prepare parameters for POST method 
    StringWriter sw = new StringWriter(); 
    JsonWriter jw = new JsonWriter(sw); 
    try { 
     jw.beginObject(); 

     jw.name("host").value("localhost"); 
     jw.name("version").value("1.1.0"); 
     jw.name("request_address").value(true); 

     jw.name("cell_towers"); 

     jw.beginArray().beginObject(); 

     jw.name("cell_id").value(gsmParams.getCid()); 
     jw.name("location_area_code").value(gsmParams.getLac()); 
     jw.name("mobile_network_code").value(gsmParams.getMnc()); 
     jw.name("mobile_country_code").value(gsmParams.getMcc()); 

     jw.endObject().endArray().endObject(); 
    } finally { 
     try { 
      jw.close(); 
     } catch (IOException ioe) { 
     } 
     try { 
      sw.close(); 
     } catch (IOException ioe) { 
     } 
    } 
    final String JsonParams = sw.toString(); 
    final String GoogleLocJsonUrl = "http://www.google.com/loc/json"; 

    // post request 
    URL url = null; 
    HttpURLConnection conn = null; 
    url = new URL(GoogleLocJsonUrl); 
    conn = (HttpURLConnection) url.openConnection(); 
    conn.setConnectTimeout((int) 30e3); 
    conn.setReadTimeout((int) 30e3); 

    conn.setDoOutput(true); 
    conn.setRequestMethod("POST"); 
    conn.getOutputStream().write(JsonParams.getBytes()); 
    conn.getOutputStream().flush(); 
    conn.getOutputStream().close(); 
    int resCode = conn.getResponseCode(); 
    if (resCode == Http_BadRequest || resCode != Http_Ok) { 
     throw new IOException(String.format(
       "Response code from Google: %,d", resCode)); 
    } 
    return conn; 
} 

El objeto GsmParams es solo un Java Bean que contiene los parámetros GSM MCC, MNC, LAC, CID. Creo que puedes crear una misma clase fácilmente.

Después de obtener la conexión, puede llamar al conn.getInputStream() y obtener resultados de Google Maps. A continuación, utilice JsonReader para analizar los datos ...

Answer 5

El nuevo lugar para la API de Google dirección es la siguiente: https://developers.google.com/maps/documentation/geolocation/intro

Con esta API, puede recuperar una ubicación a partir de información de célula (cellid, MCC, MNC, y lac)