integrating nice to another project

We are trying to integrate nice to another project.

We have a socket in which we read data when the state of nice is 
NICE_COMPONENT_STATE_READY. Then we send the data read in the socket to 
another nice agent with the function nice_agent_send.

Our doubt is what happens if no data is available in the sockt to send. 
If we don't call the function nice_agent_send (because there is no data 
available to send) can we count that cb_component_state_changed will 
fire again with the state NICE_COMPONENT_STATE_READY.

Thanks for the help.

Hi,

I'm not exactly sure why you're doing this, libnice is meant to create peer to
peer connections, it's not meant to be used on a server that proxies data
between two peers.
Either way, no, the component_state_changed only gets fired when the state of
the agent changes, so once it goes into READY, it won't get fired again. You
should start your own proxying system only after the state goes to READY.

Hope that helps,
YounessOn 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
> We are trying to integrate nice to another project.
> 
> We have a socket in which we read data when the state of nice is
> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket to another
> nice agent with the function nice_agent_send.
> 
> Our doubt is what happens if no data is available in the sockt to send. If we
> don't call the function nice_agent_send (because there is no data available to
> send) can we count that cb_component_state_changed will fire again with the
> state NICE_COMPONENT_STATE_READY.
> 
> Thanks for the help.
> _______________________________________________
> nice mailing list
> 
> http://lists.freedesktop.org/mailman/listinfo...

Youness,
Thanks for your response, what we have is a socket that bring us the information, then we transfer peer to peer with libnice, and another socket where we need to put the info that we receive from the peer to peer connection.
The issue is that the info that we need to transfer to the other peer is not given all in one call, we need to check is theres info in the socket time to time to see if theres more, and if it is, we need to send it.
Is there a way to add a signal to be called in some period of time in the future, so we can check if we have new info to transmit, or some other way to get this effect?
The other (complicated) way that I thought was to start a thread when we receive the READY state and within this thread call to receive data from the socket and call to sendit peer to peer, but I don't know if this is going to crash all over the place because the call to the libnice to send is going to be from another thread.

Another question, Is there a way to attach a function to a signal with a context? this way I don't need to have a lot of global variables.

Attached is an example of our code.

Thanks,
Andrés Suero.On 5/19/2012 5:16 PM, Youness Alaoui wrote:
> Hi,
>
> I'm not exactly sure why you're doing this, libnice is meant to create peer to
> peer connections, it's not meant to be used on a server that proxies data
> between two peers.
> Either way, no, the component_state_changed only gets fired when the state of
> the agent changes, so once it goes into READY, it won't get fired again. You
> should start your own proxying system only after the state goes to READY.
>
> Hope that helps,
> Youness
>
> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>> We are trying to integrate nice to another project.
>>
>> We have a socket in which we read data when the state of nice is
>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket to another
>> nice agent with the function nice_agent_send.
>>
>> Our doubt is what happens if no data is available in the sockt to send. If we
>> don't call the function nice_agent_send (because there is no data available to
>> send) can we count that cb_component_state_changed will fire again with the
>> state NICE_COMPONENT_STATE_READY.
>>
>> Thanks for the help.
>> _______________________________________________
>> nice mailing list
>> 
>> http://lists.freedesktop.org/mailman/listinfo...
>
>
> _______________________________________________
> nice mailing list
> 
> http://lists.freedesktop.org/mailman/listinfo...

Libnice is indeed thread safe, but you have no reason to be using a thread.
Libnice also requires you to be running the mainloop, otherwise it won't work,
so make sure to run the mainloop, as for your socket, just add a GSource on a
g_io_channel on your socket.On 05/20/2012 04:28 PM, Andrés Suero wrote:
> Youness,
> Thanks for your response, what we have is a socket that bring us the information, then we transfer peer to peer with libnice, and another socket where we need to put the info that we receive from the peer to peer connection.
> The issue is that the info that we need to transfer to the other peer is not given all in one call, we need to check is theres info in the socket time to time to see if theres more, and if it is, we need to send it.
> Is there a way to add a signal to be called in some period of time in the future, so we can check if we have new info to transmit, or some other way to get this effect?
> The other (complicated) way that I thought was to start a thread when we receive the READY state and within this thread call to receive data from the socket and call to sendit peer to peer, but I don't know if this is going to crash all over the place because the call to the libnice to send is going to be from another thread.
> 
> Another question, Is there a way to attach a function to a signal with a context? this way I don't need to have a lot of global variables.
> 
> Attached is an example of our code.
> 
> Thanks,
> Andrés Suero.
> 
> 
> 
> 
> On 5/19/2012 5:16 PM, Youness Alaoui wrote:
>> Hi,
>>
>> I'm not exactly sure why you're doing this, libnice is meant to create peer to
>> peer connections, it's not meant to be used on a server that proxies data
>> between two peers.
>> Either way, no, the component_state_changed only gets fired when the state of
>> the agent changes, so once it goes into READY, it won't get fired again. You
>> should start your own proxying system only after the state goes to READY.
>>
>> Hope that helps,
>> Youness
>>
>> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>>> We are trying to integrate nice to another project.
>>>
>>> We have a socket in which we read data when the state of nice is
>>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket to another
>>> nice agent with the function nice_agent_send.
>>>
>>> Our doubt is what happens if no data is available in the sockt to send. If we
>>> don't call the function nice_agent_send (because there is no data available to
>>> send) can we count that cb_component_state_changed will fire again with the
>>> state NICE_COMPONENT_STATE_READY.
>>>
>>> Thanks for the help.
>>> _______________________________________________
>>> nice mailing list
>>> 
>>> http://lists.freedesktop.org/mailman/listinfo...
>>
>>
>> _______________________________________________
>> nice mailing list
>> 
>> http://lists.freedesktop.org/mailman/listinfo...
> 
> 
> _______________________________________________
> nice mailing list
> 
> http://lists.freedesktop.org/mailman/listinfo...

Thanks a lot for your help Youness!On Tue, May 22, 2012 at 9:54 PM, Youness Alaoui <
 wrote:

> Libnice is indeed thread safe, but you have no reason to be using a thread.
> Libnice also requires you to be running the mainloop, otherwise it won't
> work,
> so make sure to run the mainloop, as for your socket, just add a GSource
> on a
> g_io_channel on your socket.
>
> On 05/20/2012 04:28 PM, Andrés Suero wrote:
> > Youness,
> > Thanks for your response, what we have is a socket that bring us the
> information, then we transfer peer to peer with libnice, and another socket
> where we need to put the info that we receive from the peer to peer
> connection.
> > The issue is that the info that we need to transfer to the other peer is
> not given all in one call, we need to check is theres info in the socket
> time to time to see if theres more, and if it is, we need to send it.
> > Is there a way to add a signal to be called in some period of time in
> the future, so we can check if we have new info to transmit, or some other
> way to get this effect?
> > The other (complicated) way that I thought was to start a thread when we
> receive the READY state and within this thread call to receive data from
> the socket and call to sendit peer to peer, but I don't know if this is
> going to crash all over the place because the call to the libnice to send
> is going to be from another thread.
> >
> > Another question, Is there a way to attach a function to a signal with a
> context? this way I don't need to have a lot of global variables.
> >
> > Attached is an example of our code.
> >
> > Thanks,
> > Andrés Suero.
> >
> >
> >
> >
> > On 5/19/2012 5:16 PM, Youness Alaoui wrote:
> >> Hi,
> >>
> >> I'm not exactly sure why you're doing this, libnice is meant to create
> peer to
> >> peer connections, it's not meant to be used on a server that proxies
> data
> >> between two peers.
> >> Either way, no, the component_state_changed only gets fired when the
> state of
> >> the agent changes, so once it goes into READY, it won't get fired
> again. You
> >> should start your own proxying system only after the state goes to
> READY.
> >>
> >> Hope that helps,
> >> Youness
> >>
> >> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
> >>> We are trying to integrate nice to another project.
> >>>
> >>> We have a socket in which we read data when the state of nice is
> >>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket
> to another
> >>> nice agent with the function nice_agent_send.
> >>>
> >>> Our doubt is what happens if no data is available in the sockt to
> send. If we
> >>> don't call the function nice_agent_send (because there is no data
> available to
> >>> send) can we count that cb_component_state_changed will fire again
> with the
> >>> state NICE_COMPONENT_STATE_READY.
> >>>
> >>> Thanks for the help.
> >>> _______________________________________________
> >>> nice mailing list
> >>> 
> >>> http://lists.freedesktop.org/mailman/listinfo...
> >>
> >>
> >> _______________________________________________
> >> nice mailing list
> >> 
> >> http://lists.freedesktop.org/mailman/listinfo...
> >
> >
> > _______________________________________________
> > nice mailing list
> > 
> > http://lists.freedesktop.org/mailman/listinfo...
>
>
>
> _______________________________________________
> nice mailing list
> 
> http://lists.freedesktop.org/mailman/listinfo...
>
>

Long time Youness,
I have another question, Is there an easy way to add a g_io_channel as
source and receiver of data of an agent?

Thanks a lot,
Andrés SueroOn Wed, May 23, 2012 at 10:37 AM, Andrés Suero  wrote:

> Thanks a lot for your help Youness!
>
>
> On Tue, May 22, 2012 at 9:54 PM, Youness Alaoui <
>  wrote:
>
>> Libnice is indeed thread safe, but you have no reason to be using a
>> thread.
>> Libnice also requires you to be running the mainloop, otherwise it won't
>> work,
>> so make sure to run the mainloop, as for your socket, just add a GSource
>> on a
>> g_io_channel on your socket.
>>
>> On 05/20/2012 04:28 PM, Andrés Suero wrote:
>> > Youness,
>> > Thanks for your response, what we have is a socket that bring us the
>> information, then we transfer peer to peer with libnice, and another socket
>> where we need to put the info that we receive from the peer to peer
>> connection.
>> > The issue is that the info that we need to transfer to the other peer
>> is not given all in one call, we need to check is theres info in the socket
>> time to time to see if theres more, and if it is, we need to send it.
>> > Is there a way to add a signal to be called in some period of time in
>> the future, so we can check if we have new info to transmit, or some other
>> way to get this effect?
>> > The other (complicated) way that I thought was to start a thread when
>> we receive the READY state and within this thread call to receive data from
>> the socket and call to sendit peer to peer, but I don't know if this is
>> going to crash all over the place because the call to the libnice to send
>> is going to be from another thread.
>> >
>> > Another question, Is there a way to attach a function to a signal with
>> a context? this way I don't need to have a lot of global variables.
>> >
>> > Attached is an example of our code.
>> >
>> > Thanks,
>> > Andrés Suero.
>> >
>> >
>> >
>> >
>> > On 5/19/2012 5:16 PM, Youness Alaoui wrote:
>> >> Hi,
>> >>
>> >> I'm not exactly sure why you're doing this, libnice is meant to create
>> peer to
>> >> peer connections, it's not meant to be used on a server that proxies
>> data
>> >> between two peers.
>> >> Either way, no, the component_state_changed only gets fired when the
>> state of
>> >> the agent changes, so once it goes into READY, it won't get fired
>> again. You
>> >> should start your own proxying system only after the state goes to
>> READY.
>> >>
>> >> Hope that helps,
>> >> Youness
>> >>
>> >> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>> >>> We are trying to integrate nice to another project.
>> >>>
>> >>> We have a socket in which we read data when the state of nice is
>> >>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket
>> to another
>> >>> nice agent with the function nice_agent_send.
>> >>>
>> >>> Our doubt is what happens if no data is available in the sockt to
>> send. If we
>> >>> don't call the function nice_agent_send (because there is no data
>> available to
>> >>> send) can we count that cb_component_state_changed will fire again
>> with the
>> >>> state NICE_COMPONENT_STATE_READY.
>> >>>
>> >>> Thanks for the help.
>> >>> _______________________________________________
>> >>> nice mailing list
>> >>> 
>> >>> http://lists.freedesktop.org/mailman/listinfo...
>> >>
>> >>
>> >> _______________________________________________
>> >> nice mailing list
>> >> 
>> >> http://lists.freedesktop.org/mailman/listinfo...
>> >
>> >
>> > _______________________________________________
>> > nice mailing list
>> > 
>> > http://lists.freedesktop.org/mailman/listinfo...
>>
>>
>>
>> _______________________________________________
>> nice mailing list
>> 
>> http://lists.freedesktop.org/mailman/listinfo...
>>
>>
>
>
> --
> La información transmitida es sólo para la persona o entidad a la cual está
> dirigida y puede contener material privilegiado y/o confidencial. Está
> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
> de esta información, o la realización de cualquier acto en base a esta
> información por personas o entidades diferentes a las originalmente
> dirigidas. Si ha recibido esta información por error, por favor, póngase en
> contacto con el remitente y elimine el material de cualquier computadora.
> Muchas gracias.
>
> The information transmitted is intended only for the person or entity to
> which it is addressed and may contain confidential and/or privileged
> material. Any review, retransmission, dissemination or other use of, or
> taking of any action in reliance upon, this information by persons or
> entities other than the intended recipient is prohibited. If you received
> this in error, please contact the sender and delete the material from any
> computer. Thank you.
>

I attach part of my code, please tell us if you see something fishy.

Thanks again,
Andrés SueroOn Fri, Aug 17, 2012 at 9:16 PM, Andrés Suero  wrote:

> Long time Youness,
> I have another question, Is there an easy way to add a g_io_channel as
> source and receiver of data of an agent?
>
> Thanks a lot,
> Andrés Suero
>
>
> On Wed, May 23, 2012 at 10:37 AM, Andrés Suero wrote:
>
>> Thanks a lot for your help Youness!
>>
>>
>> On Tue, May 22, 2012 at 9:54 PM, Youness Alaoui <
>>  wrote:
>>
>>> Libnice is indeed thread safe, but you have no reason to be using a
>>> thread.
>>> Libnice also requires you to be running the mainloop, otherwise it won't
>>> work,
>>> so make sure to run the mainloop, as for your socket, just add a GSource
>>> on a
>>> g_io_channel on your socket.
>>>
>>> On 05/20/2012 04:28 PM, Andrés Suero wrote:
>>> > Youness,
>>> > Thanks for your response, what we have is a socket that bring us the
>>> information, then we transfer peer to peer with libnice, and another socket
>>> where we need to put the info that we receive from the peer to peer
>>> connection.
>>> > The issue is that the info that we need to transfer to the other peer
>>> is not given all in one call, we need to check is theres info in the socket
>>> time to time to see if theres more, and if it is, we need to send it.
>>> > Is there a way to add a signal to be called in some period of time in
>>> the future, so we can check if we have new info to transmit, or some other
>>> way to get this effect?
>>> > The other (complicated) way that I thought was to start a thread when
>>> we receive the READY state and within this thread call to receive data from
>>> the socket and call to sendit peer to peer, but I don't know if this is
>>> going to crash all over the place because the call to the libnice to send
>>> is going to be from another thread.
>>> >
>>> > Another question, Is there a way to attach a function to a signal with
>>> a context? this way I don't need to have a lot of global variables.
>>> >
>>> > Attached is an example of our code.
>>> >
>>> > Thanks,
>>> > Andrés Suero.
>>> >
>>> >
>>> >
>>> >
>>> > On 5/19/2012 5:16 PM, Youness Alaoui wrote:
>>> >> Hi,
>>> >>
>>> >> I'm not exactly sure why you're doing this, libnice is meant to
>>> create peer to
>>> >> peer connections, it's not meant to be used on a server that proxies
>>> data
>>> >> between two peers.
>>> >> Either way, no, the component_state_changed only gets fired when the
>>> state of
>>> >> the agent changes, so once it goes into READY, it won't get fired
>>> again. You
>>> >> should start your own proxying system only after the state goes to
>>> READY.
>>> >>
>>> >> Hope that helps,
>>> >> Youness
>>> >>
>>> >> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>>> >>> We are trying to integrate nice to another project.
>>> >>>
>>> >>> We have a socket in which we read data when the state of nice is
>>> >>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket
>>> to another
>>> >>> nice agent with the function nice_agent_send.
>>> >>>
>>> >>> Our doubt is what happens if no data is available in the sockt to
>>> send. If we
>>> >>> don't call the function nice_agent_send (because there is no data
>>> available to
>>> >>> send) can we count that cb_component_state_changed will fire again
>>> with the
>>> >>> state NICE_COMPONENT_STATE_READY.
>>> >>>
>>> >>> Thanks for the help.
>>> >>> _______________________________________________
>>> >>> nice mailing list
>>> >>> 
>>> >>> http://lists.freedesktop.org/mailman/listinfo...
>>> >>
>>> >>
>>> >> _______________________________________________
>>> >> nice mailing list
>>> >> 
>>> >> http://lists.freedesktop.org/mailman/listinfo...
>>> >
>>> >
>>> > _______________________________________________
>>> > nice mailing list
>>> > 
>>> > http://lists.freedesktop.org/mailman/listinfo...
>>>
>>>
>>>
>>> _______________________________________________
>>> nice mailing list
>>> 
>>> http://lists.freedesktop.org/mailman/listinfo...
>>>
>>>
>>
>>
>> --
>> La información transmitida es sólo para la persona o entidad a la cual
>> está
>> dirigida y puede contener material privilegiado y/o confidencial. Está
>> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
>> de esta información, o la realización de cualquier acto en base a esta
>> información por personas o entidades diferentes a las originalmente
>> dirigidas. Si ha recibido esta información por error, por favor, póngase
>> en
>> contacto con el remitente y elimine el material de cualquier computadora.
>> Muchas gracias.
>>
>> The information transmitted is intended only for the person or entity to
>> which it is addressed and may contain confidential and/or privileged
>> material. Any review, retransmission, dissemination or other use of, or
>> taking of any action in reliance upon, this information by persons or
>> entities other than the intended recipient is prohibited. If you received
>> this in error, please contact the sender and delete the material from any
>> computer. Thank you.
>>
>
>
>
> --
> La información transmitida es sólo para la persona o entidad a la cual está
> dirigida y puede contener material privilegiado y/o confidencial. Está
> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
> de esta información, o la realización de cualquier acto en base a esta
> información por personas o entidades diferentes a las originalmente
> dirigidas. Si ha recibido esta información por error, por favor, póngase en
> contacto con el remitente y elimine el material de cualquier computadora.
> Muchas gracias.
>
> The information transmitted is intended only for the person or entity to
> which it is addressed and may contain confidential and/or privileged
> material. Any review, retransmission, dissemination or other use of, or
> taking of any action in reliance upon, this information by persons or
> entities other than the intended recipient is prohibited. If you received
> this in error, please contact the sender and delete the material from any
> computer. Thank you.
>

Sorry, this is the right code.On Fri, Aug 17, 2012 at 9:32 PM, Andrés Suero  wrote:

> I attach part of my code, please tell us if you see something fishy.
>
> Thanks again,
> Andrés Suero
>
>
> On Fri, Aug 17, 2012 at 9:16 PM, Andrés Suero  wrote:
>
>> Long time Youness,
>> I have another question, Is there an easy way to add a g_io_channel as
>> source and receiver of data of an agent?
>>
>> Thanks a lot,
>> Andrés Suero
>>
>>
>> On Wed, May 23, 2012 at 10:37 AM, Andrés Suero wrote:
>>
>>> Thanks a lot for your help Youness!
>>>
>>>
>>> On Tue, May 22, 2012 at 9:54 PM, Youness Alaoui <
>>>  wrote:
>>>
>>>> Libnice is indeed thread safe, but you have no reason to be using a
>>>> thread.
>>>> Libnice also requires you to be running the mainloop, otherwise it
>>>> won't work,
>>>> so make sure to run the mainloop, as for your socket, just add a
>>>> GSource on a
>>>> g_io_channel on your socket.
>>>>
>>>> On 05/20/2012 04:28 PM, Andrés Suero wrote:
>>>> > Youness,
>>>> > Thanks for your response, what we have is a socket that bring us the
>>>> information, then we transfer peer to peer with libnice, and another socket
>>>> where we need to put the info that we receive from the peer to peer
>>>> connection.
>>>> > The issue is that the info that we need to transfer to the other peer
>>>> is not given all in one call, we need to check is theres info in the socket
>>>> time to time to see if theres more, and if it is, we need to send it.
>>>> > Is there a way to add a signal to be called in some period of time in
>>>> the future, so we can check if we have new info to transmit, or some other
>>>> way to get this effect?
>>>> > The other (complicated) way that I thought was to start a thread when
>>>> we receive the READY state and within this thread call to receive data from
>>>> the socket and call to sendit peer to peer, but I don't know if this is
>>>> going to crash all over the place because the call to the libnice to send
>>>> is going to be from another thread.
>>>> >
>>>> > Another question, Is there a way to attach a function to a signal
>>>> with a context? this way I don't need to have a lot of global variables.
>>>> >
>>>> > Attached is an example of our code.
>>>> >
>>>> > Thanks,
>>>> > Andrés Suero.
>>>> >
>>>> >
>>>> >
>>>> >
>>>> > On 5/19/2012 5:16 PM, Youness Alaoui wrote:
>>>> >> Hi,
>>>> >>
>>>> >> I'm not exactly sure why you're doing this, libnice is meant to
>>>> create peer to
>>>> >> peer connections, it's not meant to be used on a server that proxies
>>>> data
>>>> >> between two peers.
>>>> >> Either way, no, the component_state_changed only gets fired when the
>>>> state of
>>>> >> the agent changes, so once it goes into READY, it won't get fired
>>>> again. You
>>>> >> should start your own proxying system only after the state goes to
>>>> READY.
>>>> >>
>>>> >> Hope that helps,
>>>> >> Youness
>>>> >>
>>>> >> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>>>> >>> We are trying to integrate nice to another project.
>>>> >>>
>>>> >>> We have a socket in which we read data when the state of nice is
>>>> >>> NICE_COMPONENT_STATE_READY. Then we send the data read in the
>>>> socket to another
>>>> >>> nice agent with the function nice_agent_send.
>>>> >>>
>>>> >>> Our doubt is what happens if no data is available in the sockt to
>>>> send. If we
>>>> >>> don't call the function nice_agent_send (because there is no data
>>>> available to
>>>> >>> send) can we count that cb_component_state_changed will fire again
>>>> with the
>>>> >>> state NICE_COMPONENT_STATE_READY.
>>>> >>>
>>>> >>> Thanks for the help.
>>>> >>> _______________________________________________
>>>> >>> nice mailing list
>>>> >>> 
>>>> >>> http://lists.freedesktop.org/mailman/listinfo...
>>>> >>
>>>> >>
>>>> >> _______________________________________________
>>>> >> nice mailing list
>>>> >> 
>>>> >> http://lists.freedesktop.org/mailman/listinfo...
>>>> >
>>>> >
>>>> > _______________________________________________
>>>> > nice mailing list
>>>> > 
>>>> > http://lists.freedesktop.org/mailman/listinfo...
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> nice mailing list
>>>> 
>>>> http://lists.freedesktop.org/mailman/listinfo...
>>>>
>>>>
>>>
>>>
>>> --
>>> La información transmitida es sólo para la persona o entidad a la cual
>>> está
>>> dirigida y puede contener material privilegiado y/o confidencial. Está
>>> prohibida cualquier revisión, retransmisión, difusión o cualquier otro
>>> uso
>>> de esta información, o la realización de cualquier acto en base a esta
>>> información por personas o entidades diferentes a las originalmente
>>> dirigidas. Si ha recibido esta información por error, por favor, póngase
>>> en
>>> contacto con el remitente y elimine el material de cualquier computadora.
>>> Muchas gracias.
>>>
>>> The information transmitted is intended only for the person or entity to
>>> which it is addressed and may contain confidential and/or privileged
>>> material. Any review, retransmission, dissemination or other use of, or
>>> taking of any action in reliance upon, this information by persons or
>>> entities other than the intended recipient is prohibited. If you received
>>> this in error, please contact the sender and delete the material from any
>>> computer. Thank you.
>>>
>>
>>
>>
>> --
>> La información transmitida es sólo para la persona o entidad a la cual
>> está
>> dirigida y puede contener material privilegiado y/o confidencial. Está
>> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
>> de esta información, o la realización de cualquier acto en base a esta
>> información por personas o entidades diferentes a las originalmente
>> dirigidas. Si ha recibido esta información por error, por favor, póngase
>> en
>> contacto con el remitente y elimine el material de cualquier computadora.
>> Muchas gracias.
>>
>> The information transmitted is intended only for the person or entity to
>> which it is addressed and may contain confidential and/or privileged
>> material. Any review, retransmission, dissemination or other use of, or
>> taking of any action in reliance upon, this information by persons or
>> entities other than the intended recipient is prohibited. If you received
>> this in error, please contact the sender and delete the material from any
>> computer. Thank you.
>>
>
>
>
> --
> La información transmitida es sólo para la persona o entidad a la cual está
> dirigida y puede contener material privilegiado y/o confidencial. Está
> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
> de esta información, o la realización de cualquier acto en base a esta
> información por personas o entidades diferentes a las originalmente
> dirigidas. Si ha recibido esta información por error, por favor, póngase en
> contacto con el remitente y elimine el material de cualquier computadora.
> Muchas gracias.
>
> The information transmitted is intended only for the person or entity to
> which it is addressed and may contain confidential and/or privileged
> material. Any review, retransmission, dissemination or other use of, or
> taking of any action in reliance upon, this information by persons or
> entities other than the intended recipient is prohibited. If you received
> this in error, please contact the sender and delete the material from any
> computer. Thank you.
>

Hi,
There's a "gio" branch on my repository which has an incomplete/non-working
commit which adds a GIoStream to libnice.
http://cgit.collabora.com/git/user/kakaroto/l...
Note that it hasn't been worked on since January 2010...
I suppose if that was working, you could have done a g_io_stream_splice on the 2
channels...
Other than that, no, I guess the recv callback should send on the
g_output_stream and the g_input_stream read callback should send with
nice_agent_send, and that's as simple as that.

Youness.On 08/17/2012 08:16 PM, Andrés Suero wrote:
> Long time Youness,
> I have another question, Is there an easy way to add a g_io_channel as source
> and receiver of data of an agent?
> 
> Thanks a lot,
> Andrés Suero
> 
> On Wed, May 23, 2012 at 10:37 AM, Andrés Suero 
> > wrote:
> 
>     Thanks a lot for your help Youness!
> 
> 
>     On Tue, May 22, 2012 at 9:54 PM, Youness Alaoui
>      > wrote:
> 
>         Libnice is indeed thread safe, but you have no reason to be using a thread.
>         Libnice also requires you to be running the mainloop, otherwise it won't
>         work,
>         so make sure to run the mainloop, as for your socket, just add a GSource
>         on a
>         g_io_channel on your socket.
> 
>         On 05/20/2012 04:28 PM, Andrés Suero wrote:
>         > Youness,
>         > Thanks for your response, what we have is a socket that bring us the
>         information, then we transfer peer to peer with libnice, and another
>         socket where we need to put the info that we receive from the peer to
>         peer connection.
>         > The issue is that the info that we need to transfer to the other peer
>         is not given all in one call, we need to check is theres info in the
>         socket time to time to see if theres more, and if it is, we need to send it.
>         > Is there a way to add a signal to be called in some period of time in
>         the future, so we can check if we have new info to transmit, or some
>         other way to get this effect?
>         > The other (complicated) way that I thought was to start a thread when
>         we receive the READY state and within this thread call to receive data
>         from the socket and call to sendit peer to peer, but I don't know if
>         this is going to crash all over the place because the call to the
>         libnice to send is going to be from another thread.
>         >
>         > Another question, Is there a way to attach a function to a signal with
>         a context? this way I don't need to have a lot of global variables.
>         >
>         > Attached is an example of our code.
>         >
>         > Thanks,
>         > Andrés Suero.
>         >
>         >
>         >
>         >
>         > On 5/19/2012 5:16 PM, Youness Alaoui wrote:
>         >> Hi,
>         >>
>         >> I'm not exactly sure why you're doing this, libnice is meant to
>         create peer to
>         >> peer connections, it's not meant to be used on a server that proxies data
>         >> between two peers.
>         >> Either way, no, the component_state_changed only gets fired when the
>         state of
>         >> the agent changes, so once it goes into READY, it won't get fired
>         again. You
>         >> should start your own proxying system only after the state goes to READY.
>         >>
>         >> Hope that helps,
>         >> Youness
>         >>
>         >> On 05/18/2012 11:08 PM, Federico Kouyoumdjian wrote:
>         >>> We are trying to integrate nice to another project.
>         >>>
>         >>> We have a socket in which we read data when the state of nice is
>         >>> NICE_COMPONENT_STATE_READY. Then we send the data read in the socket
>         to another
>         >>> nice agent with the function nice_agent_send.
>         >>>
>         >>> Our doubt is what happens if no data is available in the sockt to
>         send. If we
>         >>> don't call the function nice_agent_send (because there is no data
>         available to
>         >>> send) can we count that cb_component_state_changed will fire again
>         with the
>         >>> state NICE_COMPONENT_STATE_READY.
>         >>>
>         >>> Thanks for the help.
>         >>> _______________________________________________
>         >>> nice mailing list
>         >>>  
>         >>> http://lists.freedesktop.org/mailman/listinfo...
>         >>
>         >>
>         >> _______________________________________________
>         >> nice mailing list
>         >>  
>         >> http://lists.freedesktop.org/mailman/listinfo...
>         >
>         >
>         > _______________________________________________
>         > nice mailing list
>         >  
>         > http://lists.freedesktop.org/mailman/listinfo...
> 
> 
> 
>         _______________________________________________
>         nice mailing list
>          
>         http://lists.freedesktop.org/mailman/listinfo...
> 
> 
> 
> 
>     -- 
>     La información transmitida es sólo para la persona o entidad a la cual está
>     dirigida y puede contener material privilegiado y/o confidencial. Está
>     prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
>     de esta información, o la realización de cualquier acto en base a esta
>     información por personas o entidades diferentes a las originalmente
>     dirigidas. Si ha recibido esta información por error, por favor, póngase en
>     contacto con el remitente y elimine el material de cualquier computadora.
>     Muchas gracias.
>      
>     The information transmitted is intended only for the person or entity to
>     which it is addressed and may contain confidential and/or privileged
>     material. Any review, retransmission, dissemination or other use of, or
>     taking of any action in reliance upon, this information by persons or
>     entities other than the intended recipient is prohibited. If you received
>     this in error, please contact the sender and delete the material from any
>     computer. Thank you.
> 
> 
> 
> 
> -- 
> La información transmitida es sólo para la persona o entidad a la cual está
> dirigida y puede contener material privilegiado y/o confidencial. Está
> prohibida cualquier revisión, retransmisión, difusión o cualquier otro uso
> de esta información, o la realización de cualquier acto en base a esta
> información por personas o entidades diferentes a las originalmente
> dirigidas. Si ha recibido esta información por error, por favor, póngase en
> contacto con el remitente y elimine el material de cualquier computadora.
> Muchas gracias.
>  
> The information transmitted is intended only for the person or entity to
> which it is addressed and may contain confidential and/or privileged
> material. Any review, retransmission, dissemination or other use of, or
> taking of any action in reliance upon, this information by persons or
> entities other than the intended recipient is prohibited. If you received
> this in error, please contact the sender and delete the material from any
> computer. Thank you.
> 
> 
> _______________________________________________
> nice mailing list
> 
> http://lists.freedesktop.org/mailman/listinfo...