Java 计时器HttpGet asyntask到本地数据库+；在列表视图中显示
嗨，我对安卓完全陌生。非常习惯.Net和SQL Server。因此，在采用SQLite时存在问题。我目前可以通过Java 计时器HttpGet asyntask到本地数据库+；在列表视图中显示,java,android,sql,sqlite,listview,Java,Android,Sql,Sqlite,Listview,嗨，我对安卓完全陌生。非常习惯.Net和SQL Server。因此，在采用SQLite时存在问题。我目前可以通过HttpGet从URL在listView中显示结果。请对我温柔一点。非常感谢您的帮助，因为我在过去的一周里一直被困在SQLite中 只是想检查一下是否可以将其设置为 HttpGet将检索并插入SQLite表 listView从SQLite表中检索所有列数据 HttpGetAsyncTask任务只有在48小时过去后才会运行。因此，例如，如果下载发生在周一，那么如果用户在周二使用该应用程序
HttpGetlistViewHttpGetlistViewHttpGetpublic class EncounterActivity extends Activity {
ListView list;
TextView eid;
TextView eclerkship;
TextView ename;
TextView etype;
TextView erequiredattempts;
EncounterDbAdapter encounterDB;
Context myContext;
Button Btngetdata;
ArrayList<HashMap<String, String>> encouterlist = new ArrayList<HashMap<String, String>>();
//URL to get JSON Array
private static String url = "SorryHadToRemoveThisDueToSomeReason";
//JSON Node Names
private static final String TAG_ENCOUNTERS = "encounters";
private static final String TAG_E_ID = "e_id";
private static final String TAG_E_CLERKSHIP = "clerkship";
private static final String TAG_E_NAME = "encounter_name";
private static final String TAG_E_TYPE = "type";
private static final String TAG_E_REQUIRED_ATTEMPTS = "required_attempts";
JSONArray android = null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_encounter);
encouterlist = new ArrayList<HashMap<String, String>>();
new JSONParse().execute();
}
private class JSONParse extends AsyncTask<String, String, JSONObject> {
private ProgressDialog pDialog;
@Override
protected void onPreExecute() {
super.onPreExecute();
eid = (TextView)findViewById(R.id.eid);
eclerkship = (TextView)findViewById(R.id.eclerkship);
ename = (TextView)findViewById(R.id.ename);
etype = (TextView)findViewById(R.id.etype);
erequiredattempts = (TextView)findViewById(R.id.erequiredattempts);
pDialog = new ProgressDialog(EncounterActivity.this);
pDialog.setMessage("Getting Data ...");
pDialog.setIndeterminate(false);
pDialog.setCancelable(true);
pDialog.show();
}
@Override
protected JSONObject doInBackground(String... args) {
JSONParser jParser = new JSONParser();
// Getting JSON from URL
JSONObject json = jParser.getJSONFromUrl(url);
return json;
}
@Override
protected void onPostExecute(JSONObject json) {
pDialog.dismiss();
try {
// Getting JSON Array from URL
android = json.getJSONArray(TAG_ENCOUNTERS);
for(int i = 0; i < android.length(); i++){
JSONObject c = android.getJSONObject(i);
// Storing JSON item in a Variable
String eid = c.getString(TAG_E_ID);
String eclerkship = c.getString(TAG_E_CLERKSHIP);
String ename = c.getString(TAG_E_NAME);
String etype = c.getString(TAG_E_TYPE);
String erequiredattempts = c.getString(TAG_E_REQUIRED_ATTEMPTS);
// Opening of database
encounterDB = new EncounterDbAdapter(myContext);
encounterDB.open();
encounterDB.insertEncounterEntry(eid, eclerkship, ename, etype, erequiredattempts);
// Adding value HashMap key => value
HashMap<String, String> map = new HashMap<String, String>();
map.put(TAG_E_ID, eid);
map.put(TAG_E_CLERKSHIP, eclerkship);
map.put(TAG_E_NAME, ename);
map.put(TAG_E_TYPE, etype);
map.put(TAG_E_REQUIRED_ATTEMPTS, erequiredattempts);
encouterlist.add(map);
list=(ListView)findViewById(R.id.list);
ListAdapter adapter = new SimpleAdapter(EncounterActivity.this, encouterlist,
R.layout.list_v,
new String[] { TAG_E_ID, TAG_E_CLERKSHIP, TAG_E_NAME, TAG_E_TYPE, TAG_E_REQUIRED_ATTEMPTS }, new int[] {
R.id.eid, R.id.eclerkship, R.id.ename, R.id.etype, R.id.erequiredattempts});
list.setAdapter(adapter);
list.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
Toast.makeText(EncounterActivity.this, "You Clicked at "+encouterlist.get(+position).get("type"), Toast.LENGTH_SHORT).show();
}
});
}
} catch (JSONException e) {
e.printStackTrace();
}
}
}
}
public class EncounterDbAdapter {
private static final String DATABASE_NAME = "mediLearner.db";
private static final String DATABASE_TABLE = "EncounterDb";
private static final int DATABASE_VERSION = 2;
private SQLiteDatabase _db;
private final Context context;
public static final String E_ID = "_id";
public static final int COLUMN_KEY_ID = 0;
public static final String CLERKSHIP = "entry_clerkship";
public static final int COLUMN_CLERKSHIP_ID = 1;
public static final String ENCOUNTER_NAME = "entry_encounter";
public static final int COLUMN_ENCOUNTER_NAME = 2;
public static final String TYPE = "entry_type";
public static final int COLUMN_TYPE = 3;
public static final String REQUIRED_ATTEMPTS = "entry_requiredAttempts";
public static final int COLUMN_REQUIRED_ATTEMPTS = 4;
protected static final String DATABASE_CREATE = "create table "
+ DATABASE_TABLE + " (" + E_ID
+ " PRIMARY KEY, " + CLERKSHIP + " Text, "
+ ENCOUNTER_NAME + " text, " + TYPE + " Text, "
+ REQUIRED_ATTEMPTS + " Text);";
private String encounterDBADAPTER_LOG_CAT = "MY_LOG";
private myDBOpenHelper dbHelper;
public EncounterDbAdapter(Context _context) {
this.context = _context;
dbHelper = new myDBOpenHelper(context, DATABASE_NAME, null,
DATABASE_VERSION);
}
public void close() {
_db.close();
Log.w(encounterDBADAPTER_LOG_CAT, "DB closed");
}
public void open() throws SQLiteException {
try{
_db=dbHelper.getWritableDatabase();
Log.w(encounterDBADAPTER_LOG_CAT, "DB opened as writable database");
}catch(SQLiteException ex){
_db=dbHelper.getReadableDatabase();
Log.w(encounterDBADAPTER_LOG_CAT, "DB opened as readable database");
}
}
//insertion
public long insertEncounterEntry(String ID , String clerkship, String encounter, String type, String requiredAttempts ) {
//insert new task
ContentValues newEntryValues=new ContentValues();
newEntryValues.put(E_ID, ID);
newEntryValues.put(CLERKSHIP,clerkship);
newEntryValues.put(ENCOUNTER_NAME,encounter);
newEntryValues.put(TYPE, type);
newEntryValues.put(REQUIRED_ATTEMPTS, requiredAttempts);
//Insert the row
Log.w(encounterDBADAPTER_LOG_CAT, "Inserted E_ID="+ID+" CLERKSHIP="+clerkship + "Inserted ENCOUNTER_NAME="+encounter + "Inserted TYPE="+type + "Inserted REQUIRED_ATTEMPTS="+requiredAttempts +"into table"+DATABASE_TABLE);
return _db.insert(DATABASE_TABLE, null, newEntryValues);
}
public boolean removeEntry(long _rowIndex) {
if(_db.delete(DATABASE_TABLE, E_ID+"="+_rowIndex, null)<=0)
{
Log.w(encounterDBADAPTER_LOG_CAT,"Removing Entrying where id="+_rowIndex+"Failed");
return false;
}
Log.w(encounterDBADAPTER_LOG_CAT,"Removing Entrying where id="+_rowIndex+"Success");
return true;
}
//updating
public boolean updateEntry(int ID , String clerkship, String encounter_name, String type, String requiredAttempts ) {
return false;
}
//retrival
public Cursor retrieveAllEntriesCursor() {
Cursor c=null;
try{
c=_db.query(DATABASE_TABLE,new String[]{E_ID, CLERKSHIP, ENCOUNTER_NAME, TYPE, REQUIRED_ATTEMPTS}, null,null,null,null,null);
}catch(SQLException sle){
Log.w(encounterDBADAPTER_LOG_CAT,"Retrieve fail!!");
}
return c;
}
public class myDBOpenHelper extends SQLiteOpenHelper {
public myDBOpenHelper(Context context, String name,
CursorFactory factory, int version) {
super(context, name, factory, version);
// TODO Auto-generated constructor stub
}
@Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
db.execSQL(DATABASE_CREATE);
Log.w(encounterDBADAPTER_LOG_CAT, "Helper : DB " + DATABASE_TABLE
+ " Created!!");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub
}
} // End of myDBOpenHelper
}// End of myDBAdapter
public类遇到了badapter{
私有静态最终字符串数据库\u NAME=“mediLearner.db”；
私有静态最终字符串数据库\u TABLE=“EncounterDb”；
私有静态最终int数据库_VERSION=2；
私有SQLiteDatabase_db；
私人最终语境；
公共静态最终字符串E_ID=“_ID”；
公共静态final int COLUMN\u KEY\u ID=0；
公共静态最终字符串CLERKSHIP=“entry\u CLERKSHIP”；
公共静态final int COLUMN\u CLERKSHIP\u ID=1；
公共静态最终字符串遭遇\u NAME=“entry\u遭遇”；
公共静态最终整型列名称=2；
公共静态最终字符串类型=“条目类型”；
公共静态final int COLUMN_TYPE=3；
需要公共静态最终字符串\u尝试=“输入\u需要尝试”；
公共静态最终整数列\u需要\u尝试次数=4；
受保护的静态最终字符串数据库\u CREATE=“CREATE table”
+数据库表+”（“+E\U ID
+主键“+CLERKSHIP+”文本
+遇到_NAME+“text，”+TYPE+“text，”
+所需的_+Text）；
私有字符串遇到badapter\u LOG\u CAT=“MY\u LOG”；
私有myDBOpenHelper-dbHelper；
公共遭遇BAdapter（上下文_上下文）{
this.context=\u context；
dbHelper=新的myDBOpenHelper（上下文、数据库名称、null、，
数据库（U版）；
}
公众假期结束（）{
_db.close（）；
Log.w（遇到Badapter_Log_CAT，“DB关闭”）；
}
public void open（）引发SQLiteException{
试一试{
_db=dbHelper.getWritableDatabase（）；
w（遇到Badapter_Log_CAT，“数据库作为可写数据库打开”）；
}catch（SQLiteException-ex）{
_db=dbHelper.getReadableDatabase（）；
w（遇到Badapter_Log_CAT，“数据库作为可读数据库打开”）；
}
}
//插入
公共长插入计数器（字符串ID、字符串职员、字符串相遇、字符串类型、字符串所需尝试次数）{
//插入新任务
ContentValues newEntryValues=新ContentValues（）；
newEntryValues.put（E_ID，ID）；
newEntryValues.put（CLERKSHIP，CLERKSHIP）；
newEntryValues.put（遭遇战名称，遭遇战）；
newEntryValues.put（类型，类型）；
newEntryValues.put（必需的\u尝试，必需的尝试）；
//插入行
Log.w（encounterDBADAPTER_Log_CAT，“插入的E_ID=“+ID+”CLERKSHIP=“+CLERKSHIP+”插入的遭遇_NAME=“+Conference+”插入的类型=“+TYPE+”插入的所需尝试次数=“+requiredAttempts+”插入表“+数据库表”）；
返回_db.insert（数据库表，null，newEntryValues）；
}
公共布尔removeEntry（长行索引）{
如果（_db.delete（DATABASE_TABLE，E_ID+“=”+_rowIndex，null）我不会使用计时器进行更新，而是使用服务
，该服务在AlarmManager
设置的间隔上启动。如下所示：
public void setScheduling() {
Date now = new Date();
// Set the time to download to 18:00
Calendar cal = Calendar.getInstance();
cal.setTime(now);
cal.set(Calendar.HOUR_OF_DAY, 18);
cal.set(Calendar.MINUTE, 0);
AlarmManager mgr = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Intent i = new Intent(context, StartDownloadReceiver.class);
PendingIntent pi = PendingIntent.getBroadcast(context, 0, i, 0);
mgr.cancel(pi);
// 1 * 24 * 60 * 60 * 1000 = repeat this every day
mgr.setRepeating(AlarmManager.RTC, cal.getTimeInMillis(), 1 * 24 * 60 * 60 * 1000, pi);
}
在广播接收器中处理挂起的意图：
public class StartDownloadReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
boolean autoDownload = sharedPreferences.getBoolean("auto_download", false);
if (autoDownload) {
context.startService(new Intent(context, DownloaderService.class));
}
}
}
在下载服务中，您将使用AsyncTask
来下载、解析和更新数据库
我最近完成了一个要求完全相同的应用程序
每天18:00下载RSS源
如果下载和解析成功，请擦除数据库表并更新数据
发送广播以允许可能打开的任何活动
刷新其列表视图
基本上就是这样，尽管实现并不完全如此
请看这里：
另外：我在使用SQLite时使用的是OrmLite。我发现使用OrmLite比直接处理SQL简单得多，也快得多。你的问题是什么？我确实遇到了RDB。检索后插入到本地数据库中，但它显示为nullException。是否可以添加一个计时器，以便在间隔时插入？@njzk2Questi关于您编写的代码问题的ons必须在问题本身中描述特定的问题，并包括重现问题的有效代码。
public class StartDownloadReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
boolean autoDownload = sharedPreferences.getBoolean("auto_download", false);
if (autoDownload) {
context.startService(new Intent(context, DownloaderService.class));
}
}
}