pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[android] native http_thread infrastructure.

Browse source
This commit is contained in:
rachytski 2011-12-03 13:36:05 +04:00 • committed by Alex Zolotarev
parent b109fdd0e6
commit 8bc567aa34
11 changed files with 422 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
android/AndroidManifest.xml
View file

@ -13,6 +13,7 @@
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"></uses-permission>
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
<application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true">
<activity android:name=".MWMActivity"

16
android/jni/com/mapswithme/jni/jni_method.cpp
View file

@ -22,6 +22,17 @@ namespace jni
CHECK(m_index, ("Error: No valid function pointer in ", m_name));
}
Method::Method(jobject obj,
char const * name,
char const * signature)
: m_name(name),
m_signature(signature)
{
jclass k = GetCurrentThreadJNIEnv()->GetObjectClass(obj);
GetCurrentThreadJNIEnv()->GetMethodID(k, m_name, m_signature);
CHECK(m_index, ("Error: No valid function pointer in ", m_name));
}
bool Method::CallBoolean(jobject self)
{
JNIEnv* jniEnv = GetCurrentThreadJNIEnv();
@ -39,4 +50,9 @@ namespace jni
return (int)jniEnv->CallIntMethod(self, m_index);
}
jmethodID Method::GetMethodID() const
{
return m_index;
}
}

10
android/jni/com/mapswithme/jni/jni_method.hpp
View file

@ -23,8 +23,12 @@ namespace jni
public:
Method(jclass klass,
const char* name,
const char* signature);
char const * name,
char const * signature);
Method(jobject obj,
char const * name,
char const * signature);
void CallVoid(jobject self)
{
@ -61,6 +65,8 @@ namespace jni
GetCurrentThreadJNIEnv()->CallVoidMethod(self, m_index, a1, a2, a3, a4, a5);
}
jmethodID GetMethodID() const;
bool CallBoolean(jobject self);
bool CallInt(jobject self);
};

2
android/jni/com/mapswithme/jni/jni_thread.cpp
View file

@ -20,6 +20,8 @@ namespace jni
JavaVM * GetCurrentJVM()
{
if (s_jvm == 0)
LOG(LINFO, ("no current JVM"));
return s_jvm;
}

89
android/jni/com/mapswithme/maps/DownloadUI.cpp
View file

@ -7,6 +7,58 @@
#include <jni.h>
#include "Framework.hpp"
#include "DownloadUI.hpp"
#include "../jni/jni_thread.hpp"
#include "../../../../../std/bind.hpp"
#include "../../../../../base/logging.hpp"
android::DownloadUI * g_downloadUI = 0;
namespace android
{
DownloadUI::DownloadUI(jobject self)
{
m_self = jni::GetCurrentThreadJNIEnv()->NewGlobalRef(self);
jclass k = jni::GetCurrentThreadJNIEnv()->GetObjectClass(m_self);
m_onChangeCountry.reset(new jni::Method(k, "onChangeCountry", "(III)V"));
m_onProgress.reset(new jni::Method(k, "onProgress", "(IIIJJ)V"));
ASSERT(!g_downloadUI, ());
g_downloadUI = this;
}
DownloadUI::~DownloadUI()
{
jni::GetCurrentThreadJNIEnv()->DeleteGlobalRef(m_self);
g_downloadUI = 0;
}
void DownloadUI::OnChangeCountry(storage::TIndex const & idx)
{
jint group = idx.m_group;
jint country = idx.m_country;
jint region = idx.m_region;
LOG(LINFO, ("Changed Country", group, country, region));
m_onChangeCountry->CallVoid(m_self, group, country, region);
}
void DownloadUI::OnProgress(storage::TIndex const & idx, pair<int64_t, int64_t> const & p)
{
jint group = idx.m_group;
jint country = idx.m_country;
jint region = idx.m_region;
jlong p1 = p.first;
jlong p2 = p.second;
LOG(LINFO, ("Country Progress", group, country, region, p1, p2));
m_onProgress->CallVoid(m_self, group, country, region, p1, p2);
}
}
///////////////////////////////////////////////////////////////////////////////////
// DownloadUI
@ -14,6 +66,21 @@
extern "C"
{
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_DownloadUI_nativeCreate(JNIEnv * env, jobject thiz)
{
g_downloadUI = new android::DownloadUI(thiz);
g_framework->Storage().Subscribe(bind(&android::DownloadUI::OnChangeCountry, g_downloadUI, _1),
bind(&android::DownloadUI::OnProgress, g_downloadUI, _1, _2));
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_DownloadUI_nativeDestroy(JNIEnv * env, jobject thiz)
{
g_framework->Storage().Unsubscribe();
delete g_downloadUI;
}
JNIEXPORT jint JNICALL
Java_com_mapswithme_maps_DownloadUI_countriesCount(JNIEnv * env, jobject thiz,
jint group, jint country, jint region)
@ -30,14 +97,19 @@ extern "C"
}
JNIEXPORT jlong JNICALL
Java_com_mapswithme_maps_DownloadUI_countrySizeInBytes(JNIEnv * env, jobject thiz,
Java_com_mapswithme_maps_DownloadUI_countryLocalSizeInBytes(JNIEnv * env, jobject thiz,
jint group, jint country, jint region)
{
storage::LocalAndRemoteSizeT const s = g_framework->Storage().CountrySizeInBytes(storage::TIndex(group, country, region));
// lower int contains remote size, and upper - local one
int64_t mergedSize = s.second;
mergedSize |= (s.first << 32);
return mergedSize;
return s.first;
}
JNIEXPORT jlong JNICALL
Java_com_mapswithme_maps_DownloadUI_countryRemoteSizeInBytes(JNIEnv * env, jobject thiz,
jint group, jint country, jint region)
{
storage::LocalAndRemoteSizeT const s = g_framework->Storage().CountrySizeInBytes(storage::TIndex(group, country, region));
return s.second;
}
JNIEXPORT jint JNICALL
@ -46,5 +118,12 @@ extern "C"
{
return static_cast<jint>(g_framework->Storage().CountryStatus(storage::TIndex(group, country, region)));
}
JNIEXPORT jint JNICALL
Java_com_mapswithme_maps_DownloadUI_downloadCountry(JNIEnv * env, jobject thiz,
jint group, jint country, jint region)
{
g_framework->Storage().DownloadCountry(storage::TIndex(group, country, region));
}
}

28
android/jni/com/mapswithme/maps/DownloadUI.hpp Normal file
View file

@ -0,0 +1,28 @@
#pragma once
#include "Framework.hpp"
#include "../jni/jni_method.hpp"
#include "../../../../../base/base.hpp"
#include "../../../../../std/scoped_ptr.hpp"
namespace android
{
class DownloadUI
{
private:
jobject m_self;
scoped_ptr<jni::Method> m_onChangeCountry;
scoped_ptr<jni::Method> m_onProgress;
public:
DownloadUI(jobject self);
~DownloadUI();
void OnChangeCountry(storage::TIndex const & idx);
void OnProgress(storage::TIndex const & idx, pair<int64_t, int64_t> const & p);
};
}
extern android::DownloadUI * g_downloadUI;

102
android/jni/com/mapswithme/platform/http_thread_android.cpp
View file

@ -3,23 +3,101 @@
#include "../../../../../platform/http_thread_callback.hpp"
#include "../../../../../std/string.hpp"
#include "../../../../../base/logging.hpp"
#include "../maps/DownloadUI.hpp"
#include "../jni/jni_thread.hpp"
// @TODO empty stub, add android implementation
HttpThread::HttpThread(string const & url,
downloader::IHttpThreadCallback & cb,
int64_t beg,
int64_t end,
int64_t size,
string const & pb)
{
LOG(LINFO, ("creating httpThread: ", &cb, url, beg, end, size, pb));
/// should create java object here.
JNIEnv * env = jni::GetCurrentThreadJNIEnv();
LOG(LINFO, ("env : ", env));
jclass k = env->FindClass("com/mapswithme/maps/downloader/DownloadChunkTask");
jni::Method ctor(k, "<init>", "(JLjava/lang/String;JJJLjava/lang/String;)V");
jlong _id = reinterpret_cast<jlong>(&cb);
jlong _beg = static_cast<jlong>(beg);
jlong _end = static_cast<jlong>(end);
jlong _size = static_cast<jlong>(size);
jstring _url = env->NewStringUTF(url.c_str());
jstring _pb = env->NewStringUTF(pb.c_str());
m_self = env->NewObject(k, ctor.GetMethodID(), _id, _url, _beg, _end, _size, _pb);
LOG(LINFO, ("starting a newly created thread", m_self));
jni::Method startFn(k, "start", "()V");
startFn.CallVoid(m_self);
LOG(LINFO, ("started separate download thread"));
}
HttpThread::~HttpThread()
{
LOG(LINFO, ("destroying http_thread"));
JNIEnv * env = jni::GetCurrentThreadJNIEnv();
jclass k = env->FindClass("com/mapswithme/maps/downloader/DownloadChunkTask");
jni::Method cancelFn(k, "cancel", "(Z)V");
cancelFn.CallVoid(m_self, true);
env->DeleteLocalRef(m_self);
}
namespace downloader
{
HttpThread * CreateNativeHttpThread(string const & url,
downloader::IHttpThreadCallback & cb,
int64_t beg,
int64_t end,
int64_t size,
string const & pb)
{
return 0;
}
void DeleteNativeHttpThread(HttpThread * request)
{
}
HttpThread * CreateNativeHttpThread(string const & url,
downloader::IHttpThreadCallback & cb,
int64_t beg,
int64_t end,
int64_t size,
string const & pb)
{
return new HttpThread(url, cb, beg, end, size, pb);
}
void DeleteNativeHttpThread(HttpThread * request)
{
delete request;
}
} // namespace downloader
extern "C"
{
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_downloader_DownloadChunkTask_onWrite(JNIEnv * env, jobject thiz,
jlong httpCallbackID, jlong beg, jcharArray data, jlong size)
{
LOG(LINFO, ("onWrite: ", beg, size));
downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback*>(httpCallbackID);
JNIEnv * env0 = jni::GetCurrentThreadJNIEnv();
jchar * buf = env0->GetCharArrayElements(data, 0);
cb->OnWrite(beg, buf, size);
env0->ReleaseCharArrayElements(data, buf, 0);
}
JNIEXPORT void JNICALL
Java_com_mapswithme_maps_downloader_DownloadChunkTask_onFinish(JNIEnv * env, jobject thiz,
jlong httpCallbackID, jlong httpCode, jlong beg, jlong end)
{
LOG(LINFO, ("onFinish: ", httpCode, beg, end));
downloader::IHttpThreadCallback * cb = reinterpret_cast<downloader::IHttpThreadCallback*>(httpCallbackID);
cb->OnFinish(httpCode, beg, end);
}
}

16
android/jni/com/mapswithme/platform/http_thread_android.hpp
View file

@ -1,7 +1,23 @@
#pragma once
#include "../../../../../std/stdint.hpp"
#include "../../../../../std/string.hpp"
#include "../../../../../platform/http_thread_callback.hpp"
#include <jni.h>
class HttpThread
{
private:
jobject m_self;
public:
HttpThread(string const & url,
downloader::IHttpThreadCallback & cb,
int64_t beg,
int64_t end,
int64_t size,
string const & pb);
~HttpThread();
};

46
android/src/com/mapswithme/maps/DownloadUI.java
View file

@ -7,6 +7,7 @@ import android.preference.CheckBoxPreference;
import android.preference.Preference;
import android.preference.PreferenceActivity;
import android.preference.PreferenceScreen;
import android.util.Log;
public class DownloadUI extends PreferenceActivity
{
@ -14,8 +15,12 @@ public class DownloadUI extends PreferenceActivity
private native int countriesCount(int group, int country, int region);
private native int countryStatus(int group, int country, int region);
private native long countrySizeInBytes(int group, int country, int region);
private native long countryLocalSizeInBytes(int group, int country, int region);
private native long countryRemoteSizeInBytes(int group, int country, int region);
private native String countryName(int group, int country, int region);
private native void nativeCreate();
private native void nativeDestroy();
private native void downloadCountry(int group, int country, int region);
@Override
protected void onCreate(Bundle savedInstanceState)
@ -24,6 +29,28 @@ public class DownloadUI extends PreferenceActivity
// Root
PreferenceScreen root = getPreferenceManager().createPreferenceScreen(this);
setPreferenceScreen(createCountriesHierarchy(root, -1, -1, -1));
nativeCreate();
}
@Override
public void onDestroy()
{
super.onDestroy();
nativeDestroy();
}
public void onChangeCountry(int group, int country, int region)
{
Log.d(TAG, new StringBuilder("onChangeCountry %1, %2, %3").append(group).append(country).append(region).toString());
/// Should post a message onto gui thread as it could be called from the HttpThread
}
public void onProgress(int group, int country, int region, long p1, long p2)
{
Log.d(TAG, new StringBuilder("onProgress %1, %2, %3, %4, %5").append(group).append(country).append(region).append(p1).append(p2).toString());
/// Should post a message onto gui thread as it could be called from the HttpThread
}
private Preference createElement(int group, int country, int region)
@ -35,8 +62,10 @@ public class DownloadUI extends PreferenceActivity
CheckBoxPreference c = new CheckBoxPreference(this);
c.setKey(group + " " + country + " " + region);
c.setTitle(name);
final long s = countrySizeInBytes(group, country, region);
final long remoteBytes = (s & 0xffff);
final long localBytes = countryLocalSizeInBytes(group, country, region);
final long remoteBytes = countryRemoteSizeInBytes(group, country, region);
final String sizeString;
if (remoteBytes > 1024 * 1024)
sizeString = remoteBytes / (1024 * 1024) + "Mb";
@ -100,10 +129,15 @@ public class DownloadUI extends PreferenceActivity
final int country = Integer.parseInt(keys[1]);
final int region = Integer.parseInt(keys[2]);
if (((CheckBoxPreference)preference).isChecked())
/* switch (countryStatus(group, country, region))
{
//
}
case 0: //EOnDisk
{
/// Ask about deleting
}*/
downloadCountry(group, country, region);
Log.d(TAG, "started country download");
}
return super.onPreferenceTreeClick(preferenceScreen, preference);
}

136
android/src/com/mapswithme/maps/downloader/DownloadChunkTask.java Normal file
View file

@ -0,0 +1,136 @@
package com.mapswithme.maps.downloader;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import android.util.Log;
public class DownloadChunkTask extends Thread
{
private final String TAG = "DownloadChunkTask";
private long m_httpCallbackID;
private String m_url;
private long m_beg;
private long m_end;
private long m_size;
private String m_postBody;
public DownloadChunkTask(long httpCallbackID, String url, long beg, long end, long size, String postBody)
{
Log.d(TAG, "creating new task: " + httpCallbackID + url + beg + end + size + postBody);
m_httpCallbackID = httpCallbackID;
m_url = url;
m_beg = beg;
m_end = end;
m_size = size;
m_postBody = postBody;
}
public void debugPause()
{
try
{
sleep(1000);
}
catch (Exception ex)
{}
}
@Override
public void run()
{
Log.d(TAG, ("running DownloadChunkTask in separate thread"));
URL url;
try
{
url = new URL(m_url);
Log.d(TAG, ("opening connection to " + m_url));
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
Log.d(TAG, ("configuring connection parameter"));
urlConnection.setDoOutput(true);
urlConnection.setChunkedStreamingMode(0);
urlConnection.setRequestProperty("Content-Type", "application/json");
urlConnection.setUseCaches(false);
if (m_beg != -1)
{
Log.d(TAG, ("setting requested range"));
if (m_end != -1)
urlConnection.setRequestProperty("Range", new StringBuilder("bytes=%1-%2").append(m_beg).append(m_end).toString());
else
urlConnection.setRequestProperty("Range", new StringBuilder("bytes=%1-").append(m_beg).toString());
}
if (!m_postBody.isEmpty())
{
Log.d(TAG, ("writing POST body"));
DataOutputStream os = new DataOutputStream(urlConnection.getOutputStream());
os.writeChars(m_postBody);
}
Log.d(TAG, ("getting response"));
int response = urlConnection.getResponseCode();
if (response == HttpURLConnection.HTTP_OK)
{
Log.d(TAG, "saving downloaded data");
BufferedReader reader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream()));
int chunkSize = 1024 * 64;
int offs = 0;
char [] data = new char[chunkSize];
while (true)
{
long readBytes = reader.read(data);
Log.d(TAG, "got " + readBytes + " bytes of data");
if (readBytes == -1)
{
onFinish(m_httpCallbackID, 200, m_beg, m_end);
break;
}
else
{
onWrite(m_httpCallbackID, m_beg + offs, data, readBytes);
offs += readBytes;
}
}
}
else
{
onFinish(m_httpCallbackID, response, m_beg, m_end);
}
}
catch (MalformedURLException ex)
{
Log.d(TAG, "invalid url : " + m_url);
}
catch (IOException ex)
{
Log.d(TAG, "ioexception : " + ex.toString());
/// report error here
}
}
private native void onWrite(long httpCallbackID, long beg, char [] data, long size);
private native void onFinish(long httpCallbackID, long httpCode, long beg, long end);
}

2
storage/storage.hpp
View file

@ -17,7 +17,7 @@ namespace storage
/// Used in GUI
enum TStatus
{
EOnDisk,
EOnDisk = 0,
ENotDownloaded,
EDownloadFailed,
EDownloading,