Here is a great lecture video which I found to be useful. WWDC 2010 session 412 Audio Development for iPhone OS part 1. You will need a developer account (which is free) with apple and iTunes to watch the video. I hope after listening to it you will feel better (I did) :).

I was looking everywhere what is the problem. Since I am not using ANT and I dont even have a build.log which can tell me exactly what is the problem. In the past following had worked

1) Clean the project

2) Build it again.

No success.

1) Close eclipse and repeat above two steps.

That had worked in the past but this time the error was nasty :).

So I spent some time searching on net on how to find eclipse build logs. And here is the solution.

1) On Eclipse error log can be seen in Window -> Show View -> Problems

2) Now if you are like me who has selected Project -> Build Automatically, then on startup eclipse tries to load all projects in the workspace and will try to build them if they havent been already. The effect is that I have many projects for which external reference have not been resolved. This means they have lots of errors and the Problems log was full with > 3000 errors.

3) I needed to find the error for only my project. Solution for 2 is that clean all projects and unselect Build Automatically option.

4) If Problems log is still full. Right click-> Select all. Then Right click -> Delete. Now Problems log must be empty.

5) Build only your project again to see the problem.

So as is I got this funny error. Error generating final archive: Debug certificate expired on 7/30/10 10:42
PM!
Now what, another search on the web told me that Android needs a certificate to sign the applications before they get installed. Oh well!

So the solution to my problem was. Go to c:\users\<user name>\.android    folder. Delete debug.keystore file and now build in eclipse again. It will create the keystore again and now we can get back to work!!

Use method descriptors with bpmd instead. The syntax is !bpmd -md <method descriptor address> . Then the question is how to get the method descriptor address.

Use !dumpdomain – this will list all the modules in all application domains (most applications have only one appdomain).

Take the module name where your type exists and read the module address

!dumpmodule –mt <module address>

This will list the types in the module. Now pick up your types address and

!dumpmt –md <type address>

This will list all the method descriptor addresses of your type and this is what we need to put a break point.

!bpmd –md <method descriptor address>

- if you are working over wifi behind a proxy server or 3G.

- or what classes to use.

A standard Http 1.1 requests can be made using Java standard HttpUrlConnection class. There is a separate HttpsUrlConnection class for https connections. But now you will also have to write code if(http) use HttpUrlConnection elseif(https) use HttpsUrlConnection.

However, Android comes with Apache HttpClient library (which builds on Sockets) and

• is much more powerful
• easy to configure different settings,eg, https, http, proxy settings etc.
• Easy to use.
• It has a tutorial to get you going and if in doubt just read the code (its open source)!

Android itself uses this library at various places.

My experience:

• HttpUrlConnection will work over 3G with external sites. However, when you are connected to wifi it will stop working due to proxy settings. I don’t know at this point how to set the proxy settings.
• HttpClient will work with internal websites without setting proxy and external websites with setting proxy. Remember to use full fqdn always eg. https://www.google.com.

// set proxy

HttpHost proxy = new HttpHost("myproxy server", 80);

HttpParams params = new BasicHttpParams();

params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);

HttpClient httpClient = new DefaultHttpClient(this.manager, params); // this.manager is an instance of HttpConnectionManager

• Https connections over HttpClient is also very straight forward. A bit reading on Java SSL and SocketFactory is required. And then read the tutorial on HttpClient website. It takes around 1-2 hours to read the material and then its all very easy.
• If you are sending HttpRequest over Https and need to handle with self signed certificates. You will have to create EasySSLSocketFactory and EasyX509TrustManager. Again the tutorial has all the details.

WebView quirks

WebView behaves like the browser. All of the below is true for wifi.

• Proxy not set. Both will deny access to external sites. Allows access to the internal sites.
• Proxy set. Both will deny access to internal sites and deny access to external sites.

Https Connections.

• When working with browser you will get a warning for the websites which uses self signed certificates.
• When working with Webview you will need to override a function in WebViewClient class

public void onReceivedSslError(WebView view, SslErrorHandler handler, SslError error)

Unfortunately, the function is not present on Android 2.1. Fortunately, there is an easy workaround which can be followed.

Settings -> Wireless Networks ->mobile networks-> access point names->telkila. Now enter the proxy server address and port (which will be 80).

However, if you are working with WebView control in your app then above will not work unless your code has following line in onCreate()

WebView.enablePlatformNotifications();

You might want to restart the emulator after this to test your app again.

- Windows 7

- x64 dual proc

- 2GB RAM.

- Visual Studio 2010 professional

- Office 2010.

The download of 322 MB completed fairly quickly. The installation took more than an hour. Phew!!! Even my OS (windows 7) installation was quicker than that.

I hope this experience gets improved. Anyways now I shall write my first app :).

In UM Exchnage 2007 the service would automatically choose what "it thinks" is the best certificate in the machine store. However, the customer feedback told us to change this design and let admins specify what certificate to choose and tell UM for making the connections using TLS. And with this new design you dont have to learn any new cmdlets: *-exchangecertificate cmdltes can be used to create and assign a certificate to UM service.

Admins of Exchange 2007 who have used UM to make connection only over TCP will not have to make any changes. Out of the box UM continues to make connections over TCP only. 

Admins who want to accept or make secured calls using TLS will have to do following three steps. I have given some examples below.

- Change the mode of UM service from TCP to Dual or TLS. Dual mode means that the UM service will listen for calls on both TCP and TLS. TLS means that UM will listen only over TLS.

- Get a new certificate.

- Assign the certificate to UM and restart the service.

Finally, take steps so that the IP Gateway will trust and accept this certificate.

Here are some examples to do what I have mentioned above using powershell cmdlets. Same can be acheived using EMC as well. I will not be going through the EMC in this blog post.

1. Change the mode of the server to Dual or TLS using set-umserver cmdlet. As you can see it nicely gives warnings as to what are next steps.

 [PS] D:\Windows\system32>set-umserver -UMStartupMode dual -Identity EXCH-I-349
WARNING: Changes to UMStartupMode will only take effect after the Microsoft Exchange Unified Messaging service is
restarted on server EXCH-I-349.
WARNING: To complete TLS setup, do all of the following: (1) Create a new certificate using the New-ExchangeCertificate
 cmdlet (2) Associate this certificate with the Unified Messaging server using the Enable-ExchangeCertificate cmdlet
(3) For self-signed certificates, copy this certificate to the UM IP gateway and  correctly import it. For CA-signed
certificates, correctly import the CA certificate to the UM IP gateway.

2. To get a new certificate, you can use new-exchangecertificate cmdlet. This cmdlet can be used to create a new self signed certificate or a new certificate request. Details of the cmdlet can be seen at msdn.

[PS] D:\Windows\system32>New-ExchangeCertificate -Services none -Server EXCH-I-349

Thumbprint                                Services   Subject
----------                                --------   -------
80FAC0BC54F7282D14D326C34F80B02C3AA668CF  IP....     CN=EXCH-I-349

In the above example I have created a new self signed certificate which is present in the UM server's machine store and can be used by any MS Exchange service.

3) Assign the above generated self signed certificate to UM.

[PS] D:\Windows\system32>Enable-ExchangeCertificate -Services UM -Thumbprint 80FAC0BC54F7282D14D326C34F80B02C3AA668CF -s
erver EXCH-I-349

Confirm
Enable certificate with thumbprint 80FAC0BC54F7282D14D326C34F80B02C3AA668CF for Unified Messaging?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [?] Help (default is "Y"): yes
WARNING: To complete configuration (1) Restart Microsoft Exchange Unified Messaging Service on EXCH-I-349 and (2) For
self-signed certificates, install this certificate on the UM IP Gateway. For CA-signed certificates, import the CA
certificate on the UM IP Gateway.

Again notice the warning it gives.

4) Restart UM service so that it starts listening on TLS.

5) As specified by the warnings in the cmdlets ensure that the IP gateway trusts the certifcate used by the UM service. The warnings themselves are self explanatory that I wont be going through them again.

6) Check the certificate used by the services

[PS] D:\Windows\system32>Get-ExchangeCertificate

Thumbprint                                Services   Subject
----------                                --------   -------
80FAC0BC54F7282D14D326C34F80B02C3AA668CF  IPU...     CN=EXCH-I-349
3F4FF713FE8A604BCD84B20075B354DFCE36742B  IP.WS.     CN=EXCH-I-349

If your were using a self signed certificate then you could combine steps 2 and 3 together.

[PS] D:\Windows\system32>New-ExchangeCertificate -Services UM -Server EXCH-I-349

Confirm
Enable certificate with thumbprint 7B14E7BDF61F6461FBF32D4570B7DBE65E136B67 for Unified Messaging?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [?] Help (default is "Y"): yes

Thumbprint                                Services   Subject
----------                                --------   -------
7B14E7BDF61F6461FBF32D4570B7DBE65E136B67  IPU...     CN=EXCH-I-349

But I was still stuck on how to debug the service or the foo.exe launched by the service. The only clean way is to modify our code in the Main function (or OnStart if it is a service) and use Debugger.Launch() (so annoying).

public static void Main()

{

    //you can use #define DEBUG also so that this become debug only code 

    try

    {

      if (!Debugger.IsAttached)

        { 

            Debugger.Launch();

             Debugger.Break();
         }

    }

    catch (Exception ex)

    {

        //log and see which exception was thrown.
 

    } 

    // continue with your main function 

} 

But then I was interested in how things work here.

Q . How does Debugger.Launch() know which debugger to start and where is it listed?

 Ans.

The next one on my reading list is The Medical Detectives by Berton Roueche

PS: I will update this blog entry whenever I happen to find such great books.

I wrote this blog entry from a real world customer issue and noticed that how little documentation exists on this topic.

I assume that you already know what is a source interface in COM and what are IConnectionPoint and IConnectionPointContainer interfaces. Please pick up any COM book to learn that (I would reccommend Essential COM by Don Box). Also, a familiarity with the events and delegates would help.

The example code in this article are picked up from a real world scenario given by a customer.

Lets assume that we have a COM server which has a source interface as defined in the following IDL.

Note: The best way to learn from this article would be to

1) create a typelibrary from the IDL given above

2) create the interop dll using tlbimp.exe

3) Use ildasm to read what is written inside the interop dll.

In common terms we also say that the com server supports two "events" CanDoSomething and DoneSomething.

NOTE: ILegacyComObject is just some implemented interface by the com server.

When we create an inteop dll using tlbimp.exe it will contain the following classes and interfaces.

1) We need two delegates for the two events defined. Our naming convention is <interfacename>_<event name>EventHandler. Also note that since delegates are types so we will have two classes defined in the interop dll by the name:

_ILegacyComObjectEvents_CanDoSomethingEventHandler

_ILegacyComObjectEvents_DoneSomethingEventHandler

2) We have an interface defined as _ILegacyComObjectEvents with the correct ComVisible and GUID attributes.

3) Tlbimp.exe also creates a second event interface, designated by the "_Event" suffix added to the name of the original interface. This second event interface has DoneSomething and CanDoSomething events as members. It also has add and remove methods for the event delegates. In this example, the interface is called _ILegacyComObjectEvents_Event.

 4) The coclass generated would implement ILegacyComObject and _ILegacyComObjectEvents_Event (Note) and be named as LegacyComObjectClass. For points 3 and 4 also msdn has some good article https://msdn2.microsoft.com/en-us/library/k639e386.aspx

5) We generate a class <source interface name>_SinkHelper which implements the source interface methods (or in other words it implements _ILegacyComObject interface). Thus we would pass an instance of this class everytime IConnectionPoint::Advise is called. This class also stores the cookie returned from Advise.

Here is the pseudo code of the class

class _ILegacyComObjectEvents_SinkHelper : _ILegacyComObjectEvents

{

  //store the cookie returned from the IConnectionPoint::Advise call

  public Int m_dwCookie;

// store the delegates from the user

public _ILegacyComObjectEvents_CanDoSomethingEventHandler m_CanDoSomethingDelegate;

  public _ILegacyComObjectEvents_DoneSomethingEventHandler m_DoneSomethingDelegate;

 ILegacyComObject_SinkHelper ()

{

                m_dwCookie = NULL;

m_CanDoSomethingDelegate= NULL;

m_DoneSomethingDelegate = NULL;

}

bool CanDoSomething()

{

          if (m_CanDoSomethingDelegate ! = NULL)

return m_CanDoSomethingDelegate.Invoke(); //Invoke the delegate

          return 0;   // notice the default value

// See the Notes below for the return type

}

void DoneSomething()

{

          if (m_DoSomethingDelegate ! = NULL)

                return m_DoSomethingDelegate.Invoke(); //Invoke the delegate

          return;

}

}

6) We generate an EventProvider with name <source interface name>_EventProvider

This is the main class which provides the inter-operation between the COM server and the client. Note that it also implements the IDisposable interface.

Here is the pseudoCode.

class _ILegacyComObjectEvents_EventProvider: IDisposable, _ILegacyComObjectEvents_Event

{

// store the IConnectionPoint object from the COM server here

IConnectionPoint m_ConnectionPoint;

// runtime will provide the implementation of this

IConnectionPointContainer m_ConnectionPointContainer;

//arraylist of object of type SinkHelpers

ArrayList m_aEventSinkHelpers;

public _ILegacyComObject_EventProvider(Object A1)

{

  m_ConnectionPointContainer = (IConnectionPointContainer)A1;

}

void Dispose()

{

_ILegacyComObjectEvents_EventProvider::Finalize();

GC.SuppressFinalize();

}

void Finalize()

{

                // save yourself from the threading issues

System.Threading.Monitor::Enter(this);

           try

{

for (each x in m_aEventSinkHelpers)

{

  // call unadivse on each connection made

  m_ConnectionPoint.UnAdvise(((_ILegacyComObject

Events_SinkHelper)x).m_dwCookie);

}

System.Runtime.InteropServices.Marshal::ReleaseComObject(m_ConnectionPoint);

          }//end try

      catch (Exception)

     {

      }//end catch

      finally

      {

System.Threading.Monitor::Exit(this);

      }//end finally

}//end of Finalize

// This function gets the IConnectionPoint implementation from the server for the given

// interface. Also intializes the arraylist of EventSinkHelpers.

void Init ()

{

m_ConnectionPointContainer.FindConnectionPoint(guid of _ILegacyComObject,

                                                                                    &m_ConnectionPoint);

                Initialize the arraylist m_aEventSinkHelpers;

}//end of Init

public void add_CanDoSomething(_ILegacyComObjectEvents_CanDoSomethingEventHandler A_1)

{

//declare some temporary variables.

_ILegacyComObjectEvents_SinkHelper V_0;

// Save yourserlf from the threading issues.

 System.Threading.Monitor::Enter(this);

try

{

                // first check whether we have IConnectionPoint with us

 if (m_ConnectionPoint==NULL)

                                              Init();

V_0 = new _ILegacyComObjectEvents_SinkHelper();

//call the advise method

m_ConnectionPoint.Advise(V_0, &V_1);

// store the delegate and the cookie

V_0.m_dwCookie = V_1;

V_0.m_CanDoSomethingDelegate = A_1;

//add the EventSinkHelper to the arraylist

m_aEventSinkHelpers.Add((object) V_0);

} //end try

finally

{

   System.Threading.Monitor::Exit(this);

}//end finally

}// end add_CanDoSomething

// We have a similar implementation for add_DoneSomething

public void remove_CanDoSomething (_ILegacyComObjectEvents_CanDoSomethingEventHandler A_1)

{

                //declare some temporary variables

_ILegacyComObjectEvents_SinkHelper V_2;

System.Threading.Monitor::Enter(this);

try

{

for (each x in m_aEventSinkHelpers)

{

                                if ((_ILegacyComObjectEvents_SinkHelper) x.m_CanDoSomethingDelegate == A_1)

                                {

                                                m_aEventSinkHelpers.Remove(x);

                                                V_2 = (_ILegacyComObjectEvents_SinkHelper)x;

                                                m_ConnectionPoint.UnAdvise(V_2.m_dwCookie);

}             

}

 if (m_aEventSinkHelpers is empty)

    System.Runtime.InteropServices.Marshal::ReleaseComObject(m_ConnectionPoint);

}//end of try

finally

{

System.Threading.Monitor::Exit(this);

}

}//end of remove_CanDoSomething

// We have a similar implementation for remove_DoneSomething

} //end of class _ILegacyComObject_EventProvider

EventProvider does the main work for us. In general every time a user adds a delegate

1)      Get the IConnectionPointer if not available from the COM server and store it in the EvenProvider.

2)      Create a new instance of EvenSinkHelper.

3)      Call Advise and give the EventSinkHelper implementation to the server.

Here is something unexpected which the users will notice.

In COM, a user may create and give one implementation of _ILegacyComObject to the server. When the event occurs the server will call both _ILegacyComObject::CanDoSomething and _ILegacyComObject::DoneSomething. Client calls only one IConnectionPoint::Advise.

However in the managed code the user would need to do something like

private LegacyComObject m_legacyComObject;

m_legacyComObject = new LegacyComObject();

//add the delegate for CanDoSomething

m_legacyComObject.CanDoSomething += m_legacyComObject_CanDoSomething;

//add the delegate for DoneSomething

m_legacyComObject.DoneSomething += m_legacyComObject_DoneSomething;

 
// m_legacyComObject_CanDoSomething and m_legacyComObject_DoneSomething are two functions implemented in the user class.

Because we treat the two methods as two separate events we need to make two calls to _ILegacyComObjectEvents_EventProvider::add_CanDoSomething and _ILegacyComObjectEvents_EventProvider::add_DoneSomething

Looking at the pseudo code above this would lead to two separate connections or two separate Advise calls and which is inefficient.

In this case, for example, in the first call we create _ILegacyComObjectEvents_SinkHelper instance and call IConnectionPoint::Advise on it. Also notice that _ILegacyComObjectEvents_SinkHelper::m_DoneSomethingDelegate will remain NULL. If unmanaged COM server invokes this DoneSomething event then we would simply return a default value. The delegates are allowed to return only the primitive types or the value types.