2013-02-22 20 views
5

Fondamentalmente ho una classe Main che esegue l'intero progetto. Il codice funziona perfettamente anche se una volta che l'app è sfocata diventa inattiva. Mi stavo chiedendo come avrei fatto a renderlo un servizio. Uno che avrebbe avviato all'avvio.aSmack as a service

L'app sarà un sistema di segnalazione unidirezionale per le notifiche. OSSIA

Desktop Client -> Openfire Server -> Android XMPP Servizio -> Storage (DB) -> Android interfaccia grafica per la visualizzazione

Come ho detto, il codice sta lavorando (Connect, Login, ricezione), ma isn 'un servizio.

Potrei usare la fonte BEEM ma è troppo presente e interlacciata. Sto cercando un servizio leggero.

Il codice:

public class MainActivity extends Activity { 

    public static final String HOST = "fire.example.com"; 
    public static final int PORT = 5222; 
    public static final String SERVICE = "example.com"; 
    public static final String USERNAME = "[email protected]"; 
    public static final String PASSWORD = "mepass"; 

    private XMPPConnection connection; 
    private ArrayList<String> messages = new ArrayList<String>(); 
    private Handler mHandler = new Handler(); 
    private ListView listview; 
    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 

    listview = (ListView) this.findViewById(R.id.listMessages); 
    setListAdapter(); 

    connect(); 
    } 

    /** 
    * Called by Settings dialog when a connection is establised with 
    * the XMPP server 
    */ 
    public void setConnection(XMPPConnection connection) { 
    this.connection = connection; 
    if (connection != null) { 
     // Add a packet listener to get messages sent to us 
     PacketFilter filter = new MessageTypeFilter(Message.Type.chat); 
     connection.addPacketListener(new PacketListener() { 
     @Override 
     public void processPacket(Packet packet) { 
      Message message = (Message) packet; 
      if (message.getBody() != null) { 
      String fromName = StringUtils.parseBareAddress(message.getFrom()); 
      Log.i("XMPPChatActivity ", " Text Recieved " + message.getBody() + " from " + fromName); 

      messages.add(message.getBody()); 


      mHandler.post(new Runnable() { 
       public void run() { 
       setListAdapter(); 
       } 
      }); 
      } 
     } 


     }, filter); 
    } 
    } 
    @TargetApi(Build.VERSION_CODES.HONEYCOMB) 
@SuppressLint("NewApi") 


    private void setListAdapter() { 
    ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, R.layout.listitem, messages); 
    listview.setAdapter(adapter); 
    } 

    @Override 
    protected void onDestroy() { 
    super.onDestroy(); 
    try { 
     connection.disconnect(); 
    } catch (Exception e) { 

    } 
    } 

    public void connect() { 

    final ProgressDialog dialog = ProgressDialog.show(this, "Connecting...", "Please wait...", false); 
    Thread t = new Thread(new Runnable() { 
     @Override 
     public void run() { 
     // Create a connection 
     ConnectionConfiguration connConfig = new ConnectionConfiguration(HOST, PORT, SERVICE); 
     XMPPConnection connection = new XMPPConnection(connConfig); 
     try { 
      connection.connect(); 
      Log.i("XMPPChatActivity", "[SettingsDialog] Connected to "+connection.getHost()); 
     } catch (XMPPException ex) { 
      Log.e("XMPPChatActivity", "[SettingsDialog] Failed to connect to "+ connection.getHost()); 
      Log.e("XMPPChatActivity", ex.toString()); 
      setConnection(null); 
     } 
      try { 
      connection.login(USERNAME, PASSWORD); 
      Log.i("XMPPChatActivity", "Logged in as" + connection.getUser()); 

      // Set the status to available 
      Presence presence = new Presence(Presence.Type.available); 
      connection.sendPacket(presence); 
      setConnection(connection); 

      Roster roster = connection.getRoster(); 
      Collection<RosterEntry> entries = roster.getEntries(); 
      for (RosterEntry entry : entries) { 

       Log.d("XMPPChatActivity", "--------------------------------------"); 
       Log.d("XMPPChatActivity", "RosterEntry " + entry); 
       Log.d("XMPPChatActivity", "User: " + entry.getUser()); 
       Log.d("XMPPChatActivity", "Name: " + entry.getName()); 
       Log.d("XMPPChatActivity", "Status: " + entry.getStatus()); 
       Log.d("XMPPChatActivity", "Type: " + entry.getType()); 
       Presence entryPresence = roster.getPresence(entry.getUser()); 

       Log.d("XMPPChatActivity", "Presence Status: "+ entryPresence.getStatus()); 
       Log.d("XMPPChatActivity", "Presence Type: " + entryPresence.getType()); 

       Presence.Type type = entryPresence.getType(); 
       if (type == Presence.Type.available) 
       Log.d("XMPPChatActivity", "Presence AVIALABLE"); 
       Log.d("XMPPChatActivity", "Presence : " + entryPresence); 
       } 
       } catch (XMPPException ex) { 
       Log.e("XMPPChatActivity", "Failed to log in as "+ USERNAME); 
       Log.e("XMPPChatActivity", ex.toString()); 
       setConnection(null); 
       } 
       dialog.dismiss(); 
      } 
     }); 
    t.start(); 
    dialog.show(); 
    } 
} 

Quindi, fondamentalmente, come faccio a rendere questo un servizio

risposta

1

è necessario utilizzare l'Android Service Framework.

si potrebbe verificare GTalk SMS fonte come essi utilizzano un servizio ed è open source. (Il servizio principale è il servizio che usano per gestire la connessione, ecc.) Anche se è anche molto complicato.

Consiglio vivamente di dare un'occhiata alle nozioni di base sull'utilizzo di un servizio in Android.

Ricordare che un servizio non crea un nuovo thread, tutto viene ancora eseguito sul thread dell'interfaccia utente, quindi se si desidera eseguire attività a esecuzione prolungata in background, sarà inoltre necessario implementare un servizio asynctask o executor.

0

Vecchia domanda, ma comunque inserirò la mia risposta.
È necessario creare un servizio, avviarlo e inserire il codice della connessione a SMack nel servizio, non in qualsiasi attività. Il servizio manterrà la connessione anche quando l'app non è in primo piano. Sto usando questo metodo in una delle app del mio cliente e funziona alla grande.

Inoltre, assicurarsi di utilizzare un gestore o AsyncTask nel servizio per creare la connessione socket in un altro thread non UI. Android non ti consentirà comunque di creare la connessione nell'interfaccia utente.